Add files using upload-large-folder tool

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/testing/__init__.py

@@ -0,0 +1,61 @@
+import os
+import sys
+import functools
+import unittest
+import traceback
+from fnmatch import fnmatch
+from os.path import join, isfile, relpath, normpath, splitext
+
+from .main import NumbaTestProgram, SerialSuite, make_tag_decorator
+from numba.core import config
+
+
+def load_testsuite(loader, dir):
+    """Find tests in 'dir'."""
+    try:
+        suite = unittest.TestSuite()
+        files = []
+        for f in os.listdir(dir):
+            path = join(dir, f)
+            if isfile(path) and fnmatch(f, 'test_*.py'):
+                files.append(f)
+            elif isfile(join(path, '__init__.py')):
+                suite.addTests(loader.discover(path))
+        for f in files:
+            # turn 'f' into a filename relative to the toplevel dir...
+            f = relpath(join(dir, f), loader._top_level_dir)
+            # ...and translate it to a module name.
+            f = splitext(normpath(f.replace(os.path.sep, '.')))[0]
+            suite.addTests(loader.loadTestsFromName(f))
+        return suite
+    except Exception:
+        traceback.print_exc(file=sys.stderr)
+        sys.exit(-1)
+
+
+def run_tests(argv=None, defaultTest=None, topleveldir=None,
+              xmloutput=None, verbosity=1, nomultiproc=False):
+    """
+    args
+    ----
+    - xmloutput [str or None]
+        Path of XML output directory (optional)
+    - verbosity [int]
+        Verbosity level of tests output
+
+    Returns the TestResult object after running the test *suite*.
+    """
+
+    if xmloutput is not None:
+        import xmlrunner
+        runner = xmlrunner.XMLTestRunner(output=xmloutput)
+    else:
+        runner = None
+    prog = NumbaTestProgram(argv=argv,
+                            module=None,
+                            defaultTest=defaultTest,
+                            topleveldir=topleveldir,
+                            testRunner=runner, exit=False,
+                            verbosity=verbosity,
+                            nomultiproc=nomultiproc)
+    return prog.result

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/testing/__main__.py

@@ -0,0 +1,4 @@
+import sys
+from numba.testing import run_tests
+
+sys.exit(0 if run_tests(sys.argv).wasSuccessful() else 1)

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/testing/_runtests.py

@@ -0,0 +1,114 @@
+import json
+import re
+import logging
+
+
+def _main(argv, **kwds):
+    from numba.testing import run_tests
+    # This helper function assumes the first element of argv
+    # is the name of the calling program.
+    # The 'main' API function is invoked in-process, and thus
+    # will synthesize that name.
+
+    if '--log' in argv:
+        logging.basicConfig(level=logging.DEBUG)
+        argv.remove('--log')
+
+    if '--failed-first' in argv:
+        # Failed first
+        argv.remove('--failed-first')
+        return _FailedFirstRunner().main(argv, kwds)
+    elif '--last-failed' in argv:
+        argv.remove('--last-failed')
+        return _FailedFirstRunner(last_failed=True).main(argv, kwds)
+    else:
+        return run_tests(argv, defaultTest='numba.tests',
+                         **kwds).wasSuccessful()
+
+
+def main(*argv, **kwds):
+    """keyword arguments are accepted for backward compatibility only.
+    See `numba.testing.run_tests()` documentation for details."""
+    return _main(['<main>'] + list(argv), **kwds)
+
+
+class _FailedFirstRunner(object):
+    """
+    Test Runner to handle the failed-first (--failed-first) option.
+    """
+    cache_filename = '.runtests_lastfailed'
+
+    def __init__(self, last_failed=False):
+        self.last_failed = last_failed
+
+    def main(self, argv, kwds):
+        from numba.testing import run_tests
+        prog = argv[0]
+        argv = argv[1:]
+        flags = [a for a in argv if a.startswith('-')]
+
+        all_tests, failed_tests = self.find_last_failed(argv)
+        # Prepare tests to run
+        if failed_tests:
+            ft = "There were {} previously failed tests"
+            print(ft.format(len(failed_tests)))
+            remaing_tests = [t for t in all_tests
+                             if t not in failed_tests]
+            if self.last_failed:
+                tests = list(failed_tests)
+            else:
+                tests = failed_tests + remaing_tests
+        else:
+            if self.last_failed:
+                tests = []
+            else:
+                tests = list(all_tests)
+
+        if not tests:
+            print("No tests to run")
+            return True
+        # Run the testsuite
+        print("Running {} tests".format(len(tests)))
+        print('Flags', flags)
+        result = run_tests([prog] + flags + tests, **kwds)
+        # Update failed tests records only if we have run the all the tests
+        # last failed.
+        if len(tests) == result.testsRun:
+            self.save_failed_tests(result, all_tests)
+        return result.wasSuccessful()
+
+    def save_failed_tests(self, result, all_tests):
+        print("Saving failed tests to {}".format(self.cache_filename))
+        cache = []
+        # Find failed tests
+        failed = set()
+        for case in result.errors + result.failures:
+            failed.add(case[0].id())
+        # Build cache
+        for t in all_tests:
+            if t in failed:
+                cache.append(t)
+        # Write cache
+        with open(self.cache_filename, 'w') as fout:
+            json.dump(cache, fout)
+
+    def find_last_failed(self, argv):
+        from numba.tests.support import captured_output
+
+        # Find all tests
+        listargv = ['-l'] + [a for a in argv if not a.startswith('-')]
+        with captured_output("stdout") as stream:
+            main(*listargv)
+
+            pat = re.compile(r"^(\w+\.)+\w+$")
+            lines = stream.getvalue().splitlines()
+        all_tests = [x for x in lines if pat.match(x) is not None]
+
+        try:
+            fobj = open(self.cache_filename)
+        except OSError:
+            failed_tests = []
+        else:
+            with fobj as fin:
+                failed_tests = json.load(fin)
+        return all_tests, failed_tests

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/testing/loader.py

@@ -0,0 +1,26 @@
+from unittest import loader, case
+from os.path import isdir, isfile, join, dirname, basename
+
+
+class TestLoader(loader.TestLoader):
+
+    def __init__(self, topleveldir=None):
+        super(TestLoader, self).__init__()
+        self._top_level_dir = topleveldir or dirname(dirname(dirname(__file__)))
+
+    def _find_tests(self, start_dir, pattern, namespace=False):
+        # Upstream doesn't look for 'load_tests' in start_dir.
+
+        if isdir(start_dir) and not namespace and isfile(join(start_dir, '__init__.py')):
+            name = self._get_name_from_path(start_dir)
+            package = self._get_module_from_name(name)
+            load_tests = getattr(package, 'load_tests', None)
+            tests = self.loadTestsFromModule(package)
+            if load_tests is not None:
+                try:
+                    yield load_tests(self, tests, pattern)
+                except Exception as e:
+                    yield loader._make_failed_load_tests(package.__name__, e, self.suiteClass)
+        else:
+            for t in super(TestLoader, self)._find_tests(start_dir, pattern):
+                yield t

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/testing/main.py

@@ -0,0 +1,871 @@
+import collections
+import contextlib
+import cProfile
+import inspect
+import gc
+import multiprocessing
+import os
+import random
+import sys
+import time
+import unittest
+import warnings
+import zlib
+import traceback
+
+from functools import lru_cache
+from io import StringIO
+from unittest import result, runner, signals, suite, loader, case
+
+from .loader import TestLoader
+from numba.core import config
+from numba.misc import memoryutils
+
+try:
+    from multiprocessing import TimeoutError
+except ImportError:
+    from Queue import Empty as TimeoutError
+
+
+def make_tag_decorator(known_tags):
+    """
+    Create a decorator allowing tests to be tagged with the *known_tags*.
+    """
+
+    def tag(*tags):
+        """
+        Tag a test method with the given tags.
+        Can be used in conjunction with the --tags command-line argument
+        for runtests.py.
+        """
+        for t in tags:
+            if t not in known_tags:
+                raise ValueError("unknown tag: %r" % (t,))
+
+        def decorate(func):
+            if (not callable(func) or isinstance(func, type)
+                or not func.__name__.startswith('test_')):
+                raise TypeError("@tag(...) should be used on test methods")
+            try:
+                s = func.tags
+            except AttributeError:
+                s = func.tags = set()
+            s.update(tags)
+            return func
+        return decorate
+
+    return tag
+
+
+# Chances are the next queried class is the same as the previous, locally 128
+# entries seems to be fastest.
+# Current number of test classes can be found with:
+# $ ./runtests.py -l|sed -e 's/\(.*\)\..*/\1/'|grep ^numba|sort|uniq|wc -l
+# as of writing it's 658.
+@lru_cache(maxsize=128)
+def _get_mtime(cls):
+    """
+    Gets the mtime of the file in which a test class is defined.
+    """
+    return str(os.path.getmtime(inspect.getfile(cls)))
+
+
+def cuda_sensitive_mtime(x):
+    """
+    Return a key for sorting tests bases on mtime and test name. For CUDA
+    tests, interleaving tests from different classes is dangerous as the CUDA
+    context might get reset unexpectedly between methods of a class, so for
+    CUDA tests the key prioritises the test module and class ahead of the
+    mtime.
+    """
+    cls = x.__class__
+    key = _get_mtime(cls) + str(x)
+
+    from numba.cuda.testing import CUDATestCase
+    if CUDATestCase in cls.mro():
+        key = "%s.%s %s" % (str(cls.__module__), str(cls.__name__), key)
+
+    return key
+
+
+def parse_slice(useslice):
+    """Parses the argument string "useslice" as a shard index and number and
+    returns a function that filters on those arguments. i.e. input
+    useslice="1:3" leads to output something like `lambda x: zlib.crc32(x) % 3
+    == 1`.
+    """
+    if callable(useslice):
+        return useslice
+    if not useslice:
+        return lambda x: True
+    try:
+        (index, count) = useslice.split(":")
+        index = int(index)
+        count = int(count)
+    except Exception:
+        msg = (
+                    "Expected arguments shard index and count to follow "
+                    "option `-j i:t`, where i is the shard number and t "
+                    "is the total number of shards, found '%s'" % useslice)
+        raise ValueError(msg)
+    if count == 0:
+        return lambda x: True
+    elif count < 0 or index < 0 or index >= count:
+        raise ValueError("Sharding out of range")
+    else:
+        def decide(test):
+            func = getattr(test, test._testMethodName)
+            if "always_test" in getattr(func, 'tags', {}):
+                return True
+            return abs(zlib.crc32(test.id().encode('utf-8'))) % count == index
+        return decide
+
+
+class TestLister(object):
+    """Simply list available tests rather than running them."""
+    def __init__(self, useslice):
+        self.useslice = parse_slice(useslice)
+
+    def run(self, test):
+        result = runner.TextTestResult(sys.stderr, descriptions=True,
+                                       verbosity=1)
+        self._test_list = _flatten_suite(test)
+        masked_list = list(filter(self.useslice, self._test_list))
+        self._test_list.sort(key=cuda_sensitive_mtime)
+        for t in masked_list:
+            print(t.id())
+        print('%d tests found. %s selected' % (len(self._test_list),
+                                               len(masked_list)))
+        return result
+
+
+class SerialSuite(unittest.TestSuite):
+    """A simple marker to make sure tests in this suite are run serially.
+
+    Note: As the suite is going through internals of unittest,
+          it may get unpacked and stuffed into a plain TestSuite.
+          We need to set an attribute on the TestCase objects to
+          remember they should not be run in parallel.
+    """
+
+    def __init__(self, tests=()):
+        super(SerialSuite, self).__init__(tests)
+        self.resource_infos = []
+
+    def addTest(self, test):
+        if not isinstance(test, unittest.TestCase):
+            # It's a sub-suite, recurse
+            for t in test:
+                self.addTest(t)
+        else:
+            # It's a test case, mark it serial
+            test._numba_parallel_test_ = False
+            super(SerialSuite, self).addTest(test)
+
+    def run(self, result):
+        # Run each test with memory tracking
+        for test in self:
+            if result.shouldStop:
+                break
+            memtrack = memoryutils.MemoryTracker(test.id())
+            with memtrack.monitor():
+                test(result)
+            self.resource_infos.append(memtrack.get_summary())
+        return result
+
+
+class BasicTestRunner(runner.TextTestRunner):
+    def __init__(self, useslice, **kwargs):
+        runner.TextTestRunner.__init__(self, **kwargs)
+        self.useslice = parse_slice(useslice)
+
+    def run(self, test):
+        run = list(filter(self.useslice, _flatten_suite(test)))
+        run.sort(key=cuda_sensitive_mtime)
+        wrapped = unittest.TestSuite(run)
+        return super(BasicTestRunner, self).run(wrapped)
+
+
+# "unittest.main" is really the TestProgram class!
+# (defined in a module named itself "unittest.main"...)
+
+class NumbaTestProgram(unittest.main):
+    """
+    A TestProgram subclass adding the following options:
+    * a -R option to enable reference leak detection
+    * a --profile option to enable profiling of the test run
+    * a -m option for parallel execution
+    * a -l option to (only) list tests
+
+    Currently the options are only added in 3.4+.
+    """
+
+    refleak = False
+    profile = False
+    multiprocess = False
+    useslice = None
+    list = False
+    tags = None
+    exclude_tags = None
+    random_select = None
+    random_seed = 42
+
+    def __init__(self, *args, **kwargs):
+        topleveldir = kwargs.pop('topleveldir', None)
+        kwargs['testLoader'] = TestLoader(topleveldir)
+
+        # HACK to force unittest not to change warning display options
+        # (so that NumbaWarnings don't appear all over the place)
+        sys.warnoptions.append(':x')
+        self.nomultiproc = kwargs.pop('nomultiproc', False)
+        super(NumbaTestProgram, self).__init__(*args, **kwargs)
+
+    def _getParentArgParser(self):
+        # NOTE: this hook only exists on Python 3.4+. The options won't be
+        # added in earlier versions (which use optparse - 3.3 - or getopt()
+        # - 2.x).
+        parser = super(NumbaTestProgram, self)._getParentArgParser()
+        if self.testRunner is None:
+            parser.add_argument('-R', '--refleak', dest='refleak',
+                                action='store_true',
+                                help='Detect reference / memory leaks')
+        parser.add_argument('-m', '--multiprocess', dest='multiprocess',
+                            nargs='?',
+                            type=int,
+                            const=multiprocessing.cpu_count(),
+                            help='Parallelize tests')
+        parser.add_argument('-l', '--list', dest='list',
+                            action='store_true',
+                            help='List tests without running them')
+        parser.add_argument('--tags', dest='tags', type=str,
+                            help='Comma-separated list of tags to select '
+                                 'a subset of the test suite')
+        parser.add_argument('--exclude-tags', dest='exclude_tags', type=str,
+                            help='Comma-separated list of tags to de-select '
+                                 'a subset of the test suite')
+        parser.add_argument('--random', dest='random_select', type=float,
+                            help='Random proportion of tests to select')
+        parser.add_argument('--profile', dest='profile',
+                            action='store_true',
+                            help='Profile the test run')
+        parser.add_argument('-j', '--slice', dest='useslice', nargs='?',
+                            type=str, const="None",
+                            help='Shard the test sequence')
+
+        def git_diff_str(x):
+            if x != 'ancestor':
+                raise ValueError("invalid option for --gitdiff")
+            return x
+
+        parser.add_argument('-g', '--gitdiff', dest='gitdiff', type=git_diff_str,
+                            default=False, nargs='?',
+                            help=('Run tests from changes made against '
+                                  'origin/release0.65 as identified by `git diff`. '
+                                  'If set to "ancestor", the diff compares '
+                                  'against the common ancestor.'))
+        return parser
+
+    def _handle_tags(self, argv, tagstr):
+        found = None
+        for x in argv:
+            if tagstr in x:
+                if found is None:
+                    found = x
+                else:
+                    raise ValueError("argument %s supplied repeatedly" % tagstr)
+
+        if found is not None:
+            posn = argv.index(found)
+            try:
+                if found == tagstr: # --tagstr <arg>
+                    tag_args = argv[posn + 1].strip()
+                    argv.remove(tag_args)
+                else: # --tagstr=<arg>
+                    if '=' in found:
+                        tag_args =  found.split('=')[1].strip()
+                    else:
+                        raise AssertionError('unreachable')
+            except IndexError:
+                # at end of arg list, raise
+                msg = "%s requires at least one tag to be specified"
+                raise ValueError(msg % tagstr)
+            # see if next arg is "end options" or some other flag
+            if tag_args.startswith('-'):
+                raise ValueError("tag starts with '-', probably a syntax error")
+            # see if tag is something like "=<tagname>" which is likely a syntax
+            # error of form `--tags =<tagname>`, note the space prior to `=`.
+            if '=' in tag_args:
+                msg = "%s argument contains '=', probably a syntax error"
+                raise ValueError(msg % tagstr)
+            attr = tagstr[2:].replace('-', '_')
+            setattr(self, attr, tag_args)
+            argv.remove(found)
+
+
+    def parseArgs(self, argv):
+        if '-l' in argv:
+            argv.remove('-l')
+            self.list = True
+
+        super(NumbaTestProgram, self).parseArgs(argv)
+
+        # If at this point self.test doesn't exist, it is because
+        # no test ID was given in argv. Use the default instead.
+        if not hasattr(self, 'test') or not self.test.countTestCases():
+            self.testNames = (self.defaultTest,)
+            self.createTests()
+
+        if self.tags:
+            tags = [s.strip() for s in self.tags.split(',')]
+            self.test = _choose_tagged_tests(self.test, tags, mode='include')
+
+        if self.exclude_tags:
+            tags = [s.strip() for s in self.exclude_tags.split(',')]
+            self.test = _choose_tagged_tests(self.test, tags, mode='exclude')
+
+        if self.random_select:
+            self.test = _choose_random_tests(self.test, self.random_select,
+                                             self.random_seed)
+
+        if self.gitdiff is not False:
+            self.test = _choose_gitdiff_tests(
+                self.test,
+                use_common_ancestor=(self.gitdiff == 'ancestor'),
+            )
+
+        if self.verbosity <= 0:
+            # We aren't interested in informational messages / warnings when
+            # running with '-q'.
+            self.buffer = True
+
+    def _do_discovery(self, argv, Loader=None):
+        # Disable unittest's implicit test discovery when parsing
+        # CLI arguments, as it can select other tests than Numba's
+        # (e.g. some test_xxx module that may happen to be directly
+        #  reachable from sys.path)
+        return
+
+    def runTests(self):
+        if self.refleak:
+            self.testRunner = RefleakTestRunner
+
+            if not hasattr(sys, "gettotalrefcount"):
+                warnings.warn("detecting reference leaks requires a debug build "
+                              "of Python, only memory leaks will be detected")
+
+        elif self.list:
+            self.testRunner = TestLister(self.useslice)
+
+        elif self.testRunner is None:
+            self.testRunner = BasicTestRunner(self.useslice,
+                                              verbosity=self.verbosity,
+                                              failfast=self.failfast,
+                                              buffer=self.buffer)
+
+        if self.multiprocess and not self.nomultiproc:
+            if self.multiprocess < 1:
+                msg = ("Value specified for the number of processes to use in "
+                    "running the suite must be > 0")
+                raise ValueError(msg)
+            self.testRunner = ParallelTestRunner(runner.TextTestRunner,
+                                                 self.multiprocess,
+                                                 self.useslice,
+                                                 verbosity=self.verbosity,
+                                                 failfast=self.failfast,
+                                                 buffer=self.buffer)
+
+        def run_tests_real():
+            super(NumbaTestProgram, self).runTests()
+
+        if self.profile:
+            filename = os.path.splitext(
+                os.path.basename(sys.modules['__main__'].__file__)
+                )[0] + '.prof'
+            p = cProfile.Profile(timer=time.perf_counter)  # 3.3+
+            p.enable()
+            try:
+                p.runcall(run_tests_real)
+            finally:
+                p.disable()
+                print("Writing test profile data into %r" % (filename,))
+                p.dump_stats(filename)
+        else:
+            run_tests_real()
+
+
+# These are tests which are generated and injected into the test suite, what
+# gets injected depends on features of the test environment, e.g. TBB presence
+# it's important for doing the CI "slice tests" that these are run at the end
+# See notes in `_flatten_suite` for why. Simple substring matching is used to
+# determine a match.
+_GENERATED = (
+    "numba.cuda.tests.cudapy.test_libdevice.TestLibdeviceCompilation",
+    "numba.tests.test_num_threads",
+    "numba.tests.test_parallel_backend",
+    "numba.tests.test_svml",
+    "numba.tests.test_ufuncs",
+)
+
+
+def _flatten_suite_inner(test):
+    """
+    Workhorse for _flatten_suite
+    """
+    tests = []
+    if isinstance(test, (unittest.TestSuite, list, tuple)):
+        for x in test:
+            tests.extend(_flatten_suite_inner(x))
+    else:
+        tests.append(test)
+    return tests
+
+
+def _flatten_suite(test):
+    """
+    Expand nested suite into list of test cases.
+    """
+    tests = _flatten_suite_inner(test)
+    # Strip out generated tests and stick them at the end, this is to make sure
+    # that tests appear in a consistent order regardless of features available.
+    # This is so that a slice through the test suite e.g. (1::N) would likely be
+    # consistent up to the point of the generated tests, which rely on specific
+    # features.
+    generated = set()
+    for t in tests:
+        for g in _GENERATED:
+            if g in str(t):
+                generated.add(t)
+    normal = set(tests) - generated
+    def key(x):
+        return x.__module__, type(x).__name__, x._testMethodName
+    tests = sorted(normal, key=key)
+    tests.extend(sorted(list(generated), key=key))
+    return tests
+
+
+def _choose_gitdiff_tests(tests, *, use_common_ancestor=False):
+    try:
+        from git import Repo
+    except ImportError:
+        raise ValueError("gitpython needed for git functionality")
+    repo = Repo('.')
+    path = os.path.join('numba', 'tests')
+    if use_common_ancestor:
+        print(f"Git diff by common ancestor")
+        target = 'origin/release0.65...HEAD'
+    else:
+        target = 'origin/release0.65..HEAD'
+    gdiff_paths = repo.git.diff(target, path, name_only=True).split()
+    # normalise the paths as they are unix style from repo.git.diff
+    gdiff_paths = [os.path.normpath(x) for x in gdiff_paths]
+    selected = []
+    gdiff_paths = [os.path.join(repo.working_dir, x) for x in gdiff_paths]
+    for test in _flatten_suite(tests):
+        assert isinstance(test, unittest.TestCase)
+        fname = inspect.getsourcefile(test.__class__)
+        if fname in gdiff_paths:
+            selected.append(test)
+    print("Git diff identified %s tests" % len(selected))
+    return unittest.TestSuite(selected)
+
+def _choose_tagged_tests(tests, tags, mode='include'):
+    """
+    Select tests that are tagged/not tagged with at least one of the given tags.
+    Set mode to 'include' to include the tests with tags, or 'exclude' to
+    exclude the tests with the tags.
+    """
+    selected = []
+    tags = set(tags)
+    for test in _flatten_suite(tests):
+        assert isinstance(test, unittest.TestCase)
+        func = getattr(test, test._testMethodName)
+        try:
+            # Look up the method's underlying function (Python 2)
+            func = func.im_func
+        except AttributeError:
+            pass
+
+        found_tags = getattr(func, 'tags', None)
+        # only include the test if the tags *are* present
+        if mode == 'include':
+            if found_tags is not None and found_tags & tags:
+                selected.append(test)
+        elif mode == 'exclude':
+            # only include the test if the tags *are not* present
+            if found_tags is None or not (found_tags & tags):
+                selected.append(test)
+        else:
+            raise ValueError("Invalid 'mode' supplied: %s." % mode)
+    return unittest.TestSuite(selected)
+
+
+def _choose_random_tests(tests, ratio, seed):
+    """
+    Choose a given proportion of tests at random.
+    """
+    rnd = random.Random()
+    rnd.seed(seed)
+    if isinstance(tests, unittest.TestSuite):
+        tests = _flatten_suite(tests)
+    tests = rnd.sample(tests, int(len(tests) * ratio))
+    tests = sorted(tests, key=lambda case: case.id())
+    return unittest.TestSuite(tests)
+
+
+# The reference leak detection code is liberally taken and adapted from
+# Python's own Lib/test/regrtest.py.
+
+def _refleak_cleanup():
+    # Collect cyclic trash and read memory statistics immediately after.
+    func1 = sys.getallocatedblocks
+    try:
+        func2 = sys.gettotalrefcount
+    except AttributeError:
+        func2 = lambda: 42
+
+    # Flush standard output, so that buffered data is sent to the OS and
+    # associated Python objects are reclaimed.
+    for stream in (sys.stdout, sys.stderr, sys.__stdout__, sys.__stderr__):
+        if stream is not None:
+            stream.flush()
+
+    sys._clear_type_cache()
+    # This also clears the various internal CPython freelists.
+    gc.collect()
+    return func1(), func2()
+
+
+class ReferenceLeakError(RuntimeError):
+    pass
+
+
+class IntPool(collections.defaultdict):
+
+    def __missing__(self, key):
+        return key
+
+
+class RefleakTestResult(runner.TextTestResult):
+
+    warmup = 3
+    repetitions = 6
+
+    def _huntLeaks(self, test):
+        self.stream.flush()
+
+        repcount = self.repetitions
+        nwarmup = self.warmup
+        rc_deltas = [0] * (repcount - nwarmup)
+        alloc_deltas = [0] * (repcount - nwarmup)
+        # Preallocate ints likely to be stored in rc_deltas and alloc_deltas,
+        # to make sys.getallocatedblocks() less flaky.
+        _int_pool = IntPool()
+        for i in range(-200, 200):
+            _int_pool[i]
+
+        for i in range(repcount):
+            # Use a pristine, silent result object to avoid recursion
+            res = result.TestResult()
+            test.run(res)
+            # Poorly-written tests may fail when run several times.
+            # In this case, abort the refleak run and report the failure.
+            if not res.wasSuccessful():
+                self.failures.extend(res.failures)
+                self.errors.extend(res.errors)
+                raise AssertionError
+            del res
+            alloc_after, rc_after = _refleak_cleanup()
+            if i >= nwarmup:
+                rc_deltas[i - nwarmup] = _int_pool[rc_after - rc_before]
+                alloc_deltas[i - nwarmup] = _int_pool[alloc_after - alloc_before]
+            alloc_before, rc_before = alloc_after, rc_after
+        return rc_deltas, alloc_deltas
+
+    def addSuccess(self, test):
+        try:
+            rc_deltas, alloc_deltas = self._huntLeaks(test)
+        except AssertionError:
+            # Test failed when repeated
+            assert not self.wasSuccessful()
+            return
+
+        # These checkers return False on success, True on failure
+        def check_rc_deltas(deltas):
+            return any(deltas)
+
+        def check_alloc_deltas(deltas):
+            # At least 1/3rd of 0s
+            if 3 * deltas.count(0) < len(deltas):
+                return True
+            # Nothing else than 1s, 0s and -1s
+            if not set(deltas) <= set((1, 0, -1)):
+                return True
+            return False
+
+        failed = False
+
+        for deltas, item_name, checker in [
+            (rc_deltas, 'references', check_rc_deltas),
+            (alloc_deltas, 'memory blocks', check_alloc_deltas)]:
+            if checker(deltas):
+                msg = '%s leaked %s %s, sum=%s' % (
+                    test, deltas, item_name, sum(deltas))
+                failed = True
+                try:
+                    raise ReferenceLeakError(msg)
+                except Exception:
+                    exc_info = sys.exc_info()
+                if self.showAll:
+                    self.stream.write("%s = %r " % (item_name, deltas))
+                self.addFailure(test, exc_info)
+
+        if not failed:
+            super(RefleakTestResult, self).addSuccess(test)
+
+
+class RefleakTestRunner(runner.TextTestRunner):
+    resultclass = RefleakTestResult
+
+
+class ParallelTestResult(runner.TextTestResult):
+    """
+    A TestResult able to inject results from other results.
+    """
+
+    def add_results(self, result):
+        """
+        Add the results from the other *result* to this result.
+        """
+        self.stream.write(result.stream.getvalue())
+        self.stream.flush()
+        self.testsRun += result.testsRun
+        self.failures.extend(result.failures)
+        self.errors.extend(result.errors)
+        self.skipped.extend(result.skipped)
+        self.expectedFailures.extend(result.expectedFailures)
+        self.unexpectedSuccesses.extend(result.unexpectedSuccesses)
+
+
+class _MinimalResult(object):
+    """
+    A minimal, picklable TestResult-alike object.
+    """
+
+    __slots__ = (
+        'failures', 'errors', 'skipped', 'expectedFailures',
+        'unexpectedSuccesses', 'stream', 'shouldStop', 'testsRun',
+        'test_id', 'resource_info')
+
+    def fixup_case(self, case):
+        """
+        Remove any unpicklable attributes from TestCase instance *case*.
+        """
+        # Python 3.3 doesn't reset this one.
+        case._outcomeForDoCleanups = None
+
+    def __init__(self, original_result, test_id=None, resource_info=None):
+        for attr in self.__slots__:
+            setattr(self, attr, getattr(original_result, attr, None))
+        for case, _ in self.expectedFailures:
+            self.fixup_case(case)
+        for case, _ in self.errors:
+            self.fixup_case(case)
+        for case, _ in self.failures:
+            self.fixup_case(case)
+        self.test_id = test_id
+        self.resource_info = resource_info
+
+
+class _FakeStringIO(object):
+    """
+    A trivial picklable StringIO-alike for Python 2.
+    """
+
+    def __init__(self, value):
+        self._value = value
+
+    def getvalue(self):
+        return self._value
+
+
+class _MinimalRunner(object):
+    """
+    A minimal picklable object able to instantiate a runner in a
+    child process and run a test case with it.
+    """
+
+    def __init__(self, runner_cls, runner_args):
+        self.runner_cls = runner_cls
+        self.runner_args = runner_args
+
+    # Python 2 doesn't know how to pickle instance methods, so we use __call__
+    # instead.
+
+    def __call__(self, test):
+        # Executed in child process
+        kwargs = self.runner_args
+        # Force recording of output in a buffer (it will be printed out
+        # by the parent).
+        kwargs['stream'] = StringIO()
+        runner = self.runner_cls(**kwargs)
+        result = runner._makeResult()
+        # Avoid child tracebacks when Ctrl-C is pressed.
+        signals.installHandler()
+        signals.registerResult(result)
+        result.failfast = runner.failfast
+        result.buffer = runner.buffer
+        # Create a per-process memory tracker to avoid global state issues
+        memtrack = memoryutils.MemoryTracker(test.id())
+        with memtrack.monitor():
+            with self.cleanup_object(test):
+                test(result)
+        # HACK as cStringIO.StringIO isn't picklable in 2.x
+        result.stream = _FakeStringIO(result.stream.getvalue())
+        return _MinimalResult(result, test.id(),
+                              resource_info=memtrack.get_summary())
+
+    @contextlib.contextmanager
+    def cleanup_object(self, test):
+        """
+        A context manager which cleans up unwanted attributes on a test case
+        (or any other object).
+        """
+        vanilla_attrs = set(test.__dict__)
+        try:
+            yield test
+        finally:
+            spurious_attrs = set(test.__dict__) - vanilla_attrs
+            for name in spurious_attrs:
+                del test.__dict__[name]
+
+
+def _split_nonparallel_tests(test, sliced):
+    """
+    Split test suite into parallel and serial tests.
+    """
+    ptests = []
+    stests = []
+
+    flat = [*filter(sliced, _flatten_suite(test))]
+
+    def is_parallelizable_test_case(test):
+        # Guard for the fake test case created by unittest when test
+        # discovery fails, as it isn't picklable (e.g. "LoadTestsFailure")
+        method_name = test._testMethodName
+        method = getattr(test, method_name)
+        if method.__name__ != method_name and method.__name__ == "testFailure":
+            return False
+        # Was parallel execution explicitly disabled?
+        return getattr(test, "_numba_parallel_test_", True)
+
+    for t in flat:
+        if is_parallelizable_test_case(t):
+            ptests.append(t)
+        else:
+            stests.append(t)
+
+    return ptests, stests
+
+# A test can't run longer than 10 minutes
+_TIMEOUT = 1200
+
+class ParallelTestRunner(runner.TextTestRunner):
+    """
+    A test runner which delegates the actual running to a pool of child
+    processes.
+    """
+
+    resultclass = ParallelTestResult
+    timeout = _TIMEOUT
+
+    def __init__(self, runner_cls, nprocs, useslice, **kwargs):
+        runner.TextTestRunner.__init__(self, **kwargs)
+        self.runner_cls = runner_cls
+        self.nprocs = nprocs
+        self.useslice = parse_slice(useslice)
+        self.runner_args = kwargs
+        self.resource_infos = []
+
+    def _run_inner(self, result):
+        # We hijack TextTestRunner.run()'s inner logic by passing this
+        # method as if it were a test case.
+        child_runner = _MinimalRunner(self.runner_cls, self.runner_args)
+
+        # Split the tests and recycle the worker process to tame memory usage.
+        chunk_size = 100
+        splitted_tests = [self._ptests[i:i + chunk_size]
+                          for i in range(0, len(self._ptests), chunk_size)]
+
+        spawnctx = multiprocessing.get_context("spawn")
+        try:
+            for tests in splitted_tests:
+                pool = spawnctx.Pool(self.nprocs)
+                try:
+                    self._run_parallel_tests(result, pool, child_runner, tests)
+                except Exception:
+                    # On exception, kill still active workers immediately
+                    pool.terminate()
+                    # Make sure exception is reported and not ignored
+                    raise
+                else:
+                    # Close the pool cleanly unless asked to early out
+                    if result.shouldStop:
+                        pool.terminate()
+                        break
+                    else:
+                        pool.close()
+                finally:
+                    # Always join the pool (this is necessary for coverage.py)
+                    pool.join()
+            if not result.shouldStop:
+                # Run serial tests with memory tracking
+                stests = SerialSuite(self._stests)
+                stests.run(result)
+                # Add serial test resource infos to the main collection
+                self.resource_infos.extend(stests.resource_infos)
+                return result
+        finally:
+            # Always display the resource infos
+            if memoryutils.IS_SUPPORTED:
+                try:
+                    print("=== Resource Infos ===")
+                    for ri in self.resource_infos:
+                        print(ri)
+                except Exception:
+                    print("ERROR: Ignored exception in priting resource infos")
+                    traceback.print_exc()
+                finally:
+                    print("=== End Resource Infos ===")
+
+    def _run_parallel_tests(self, result, pool, child_runner, tests):
+        remaining_ids = set(t.id() for t in tests)
+        tests.sort(key=cuda_sensitive_mtime)
+        it = pool.imap_unordered(child_runner, tests)
+        while True:
+            try:
+                child_result = it.__next__(self.timeout)
+            except StopIteration:
+                return
+            except TimeoutError as e:
+                # Diagnose the names of unfinished tests
+                msg = ("Tests didn't finish before timeout (or crashed):\n%s"
+                       % "".join("- %r\n" % tid for tid in sorted(remaining_ids))
+                       )
+                e.args = (msg,) + e.args[1:]
+                raise e
+            else:
+                result.add_results(child_result)
+                self.resource_infos.append(child_result.resource_info)
+                remaining_ids.discard(child_result.test_id)
+                if child_result.shouldStop:
+                    result.shouldStop = True
+                    return
+
+    def run(self, test):
+        self._ptests, self._stests = _split_nonparallel_tests(test,
+                                                              self.useslice)
+        print("Parallel: %s. Serial: %s" % (len(self._ptests),
+                                            len(self._stests)))
+        # This will call self._run_inner() on the created result object,
+        # and print out the detailed test results at the end.
+        return super(ParallelTestRunner, self).run(self._run_inner)

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/testing/notebook.py

@@ -0,0 +1,171 @@
+from unittest import TestCase
+
+from ipykernel.tests import utils
+from nbformat.converter import convert
+from nbformat.reader import reads
+
+import re
+import json
+from copy import copy
+import unittest
+
+try:
+    # py3
+    from queue import Empty
+
+    def isstr(s):
+        return isinstance(s, str)
+except ImportError:
+    # py2
+    from Queue import Empty
+
+    def isstr(s):
+        return isinstance(s, basestring)  # noqa
+
+class NotebookTest(TestCase):
+    """Validate a notebook. All code cells are executed in order. The output is either checked
+    for errors (if no reference output is present), or is compared against expected output.
+
+
+    Useful references:
+    http://nbformat.readthedocs.org/en/latest/format_description.html
+    http://jupyter-client.readthedocs.org/en/latest/messaging.html
+"""
+
+
+    IGNORE_TYPES = ["execute_request", "execute_input", "status", "pyin"]
+    STRIP_KEYS = ["execution_count", "traceback", "prompt_number", "source"]
+    NBFORMAT_VERSION = 4
+
+    def _test_notebook(self, notebook, test):
+
+        with open(notebook) as f:
+            nb = convert(reads(f.read()), self.NBFORMAT_VERSION)
+        _, kernel = utils.start_new_kernel()
+        for i, c in enumerate([c for c in nb.cells if c.cell_type == 'code']):
+            self._test_notebook_cell(self.sanitize_cell(c), i, kernel, test)
+
+    def _test_notebook_cell(self, cell, i, kernel, test):
+
+        if hasattr(cell, 'source'): # nbformat 4.0 and later
+            code = cell.source
+        else:
+            code = cell.input
+        iopub = kernel.iopub_channel
+        kernel.execute(code)
+        outputs = []
+        msg = None
+        no_error = True
+        first_error = -1
+        error_msg = ''
+        while self.should_continue(msg):
+            try:
+                msg = iopub.get_msg(block=True, timeout=1)
+            except Empty:
+                continue
+            if msg['msg_type'] not in self.IGNORE_TYPES:
+                if msg['msg_type'] == 'error':
+                    error_msg = '  ' + msg['content']['ename'] + '\n  ' + msg['content']['evalue']
+                    no_error = False
+                    if first_error == -1:
+                        first_error = i
+                i = len(outputs)
+                expected = i < len(cell.outputs) and cell.outputs[i] or []
+                o = self.transform_message(msg, expected)
+                outputs.append(o)
+
+        if (test == 'check_error'):
+            self.assertTrue(no_error, 'Executing cell %d resulted in an error:\n%s'%(first_error, error_msg))
+        else:
+            # Compare computed output against stored output.
+            # TODO: This doesn't work right now as the generated output is too diverse to
+            #       be verifiable.
+            scrub = lambda x: self.dump_canonical(list(self.scrub_outputs(x)))
+            scrubbed = scrub(outputs)
+            expected = scrub(cell.outputs)
+            #print('output=%s'%outputs)
+            #print('expected=%s'%expected)
+            #self.assertEqual(scrubbed, expected, "\n{}\n\n{}".format(scrubbed, expected))
+        
+    def dump_canonical(self, obj):
+        return json.dumps(obj, indent=2, sort_keys=True)
+
+    def scrub_outputs(self, outputs):
+        """
+        remove all scrubs from output data and text
+        """
+        for output in outputs:
+            out = copy(output)
+
+            for scrub, sub in []:#self.scrubs.items():
+                def _scrubLines(lines):
+                    if isstr(lines):
+                        return re.sub(scrub, sub, lines)
+                    else:
+                        return [re.sub(scrub, sub, line) for line in lines]
+
+                if "text" in out:
+                    out["text"] = _scrubLines(out["text"])
+
+                if "data" in out:
+                    if isinstance(out["data"], dict):
+                        for mime, data in out["data"].items():
+                            out["data"][mime] = _scrubLines(data)
+                    else:
+                        out["data"] = _scrubLines(out["data"])
+            yield out
+
+    def strip_keys(self, d):
+        """
+        remove keys from STRIP_KEYS to ensure comparability
+        """
+        for key in self.STRIP_KEYS:
+            d.pop(key, None)
+        return d
+
+    def sanitize_cell(self, cell):
+        """
+        remove non-reproducible things
+        """
+        for output in cell.outputs:
+            self.strip_keys(output)
+        return cell
+
+    def transform_message(self, msg, expected):
+        """
+        transform a message into something like the notebook
+        """
+        SWAP_KEYS = {
+            "output_type": {
+                "pyout": "execute_result",
+                "pyerr": "error"
+            }
+        }
+
+        output = {
+            u"output_type": msg["msg_type"]
+        }
+        output.update(msg["content"])
+
+        output = self.strip_keys(output)
+        for key, swaps in SWAP_KEYS.items():
+            if key in output and output[key] in swaps:
+                output[key] = swaps[output[key]]
+
+        if "data" in output and "data" not in expected:
+            output["text"] = output["data"]
+            del output["data"]
+
+        return output
+
+    def should_continue(self, msg):
+        """
+        determine whether the current message is the last for this cell
+        """
+        if msg is None:
+            return True
+
+        return not (msg["msg_type"] == "status" and
+                    msg["content"]["execution_state"] == "idle")
+
+

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/cfunc_cache_usecases.py

@@ -0,0 +1,70 @@
+"""
+This file will be copied to a temporary directory in order to
+exercise caching compiled C callbacks.
+
+See test_cfunc.py.
+"""
+
+import sys
+
+from numba import cfunc, jit
+from numba.tests.support import TestCase, captured_stderr
+
+
+Z = 1
+
+add_sig = "float64(float64, float64)"
+
+div_sig = "float64(int64, int64)"
+
+
+@cfunc(add_sig, cache=True, nopython=True)
+def add_usecase(x, y):
+    return x + y + Z
+
+@cfunc(add_sig, nopython=True)
+def add_nocache_usecase(x, y):
+    return x + y + Z
+
+@cfunc(div_sig, cache=True, nopython=True)
+def div_usecase(a, b):
+    return a / b
+
+
+@jit(nopython=True)
+def inner(x, y):
+    return x + y + Z
+
+@cfunc(add_sig, cache=True, nopython=True)
+def outer(x, y):
+    return inner(-y, x)
+
+
+class _TestModule(TestCase):
+    """
+    Tests for functionality of this module's cfuncs.
+    Note this does not define any "test_*" method, instead check_module()
+    should be called by hand.
+    """
+
+    def check_module(self, mod):
+        f = mod.add_usecase
+        self.assertPreciseEqual(f.ctypes(2.0, 3.0), 6.0)
+        f = mod.add_nocache_usecase
+        self.assertPreciseEqual(f.ctypes(2.0, 3.0), 6.0)
+        f = mod.outer
+        self.assertPreciseEqual(f.ctypes(5.0, 2.0), 4.0)
+
+        f = mod.div_usecase
+        with captured_stderr() as err:
+            self.assertPreciseEqual(f.ctypes(7, 2), 3.5)
+        self.assertEqual(err.getvalue(), "")
+        with captured_stderr() as err:
+            f.ctypes(7, 0)
+        err = err.getvalue()
+        self.assertIn("ZeroDivisionError", err)
+
+
+def self_test():
+    mod = sys.modules[__name__]
+    _TestModule().check_module(mod)

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/gdb/__init__.py

@@ -0,0 +1,10 @@
+from os.path import dirname
+import unittest
+from unittest.suite import TestSuite
+
+from numba.testing import load_testsuite
+
+def load_tests(loader, tests, pattern):
+    suite = TestSuite()
+    suite.addTests(load_testsuite(loader, dirname(__file__)))
+    return suite

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/gdb/test_array_arg.py

@@ -0,0 +1,51 @@
+# NOTE: This test is sensitive to line numbers as it checks breakpoints
+from numba import njit, types
+import numpy as np
+from numba.tests.gdb_support import GdbMIDriver
+from numba.tests.support import TestCase, needs_subprocess
+import unittest
+
+
+@needs_subprocess
+class Test(TestCase):
+
+    def test(self):
+        @njit(debug=True)
+        def foo(x):
+            z = np.ones_like(x) # break here
+            return x, z
+
+        tmp = np.ones(5)
+        foo(tmp)
+
+        driver = GdbMIDriver(__file__)
+        driver.set_breakpoint(line=15)
+        driver.run()
+        driver.check_hit_breakpoint(1)
+        driver.stack_list_arguments(2)
+        llvm_intp = f"i{types.intp.bitwidth}"
+        expect = (
+            '[frame={level="0",args=[{name="x",type="array(float64, 1d, C) '
+            f'({{i8*, i8*, {llvm_intp}, {llvm_intp}, double*, '
+            f'[1 x {llvm_intp}], [1 x {llvm_intp}]}})"}}]}}]'
+        )
+        driver.assert_output(expect)
+        driver.stack_list_variables(1)
+        # 'z' should be zero-init
+        expect = ('{name="z",value="{meminfo = 0x0, parent = 0x0, nitems = 0, '
+                  'itemsize = 0, data = 0x0, shape = {0}, strides = {0}}"}')
+        driver.assert_output(expect)
+        driver.set_breakpoint(line=16)
+        driver.cont()
+        driver.check_hit_breakpoint(2)
+        driver.stack_list_variables(1)
+        # 'z' should be populated
+        expect = (r'^.*\{name="z",value="\{meminfo = 0x[0-9a-f]+ .*, '
+                  r'parent = 0x0, nitems = 5, itemsize = 8, '
+                  r'data = 0x[0-9a-f]+, shape = \{5\}, strides = \{8\}\}.*$')
+        driver.assert_regex_output(expect)
+        driver.quit()
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/gdb/test_basic.py

@@ -0,0 +1,39 @@
+# NOTE: This test is sensitive to line numbers as it checks breakpoints
+from numba import njit, types
+from numba.tests.gdb_support import GdbMIDriver
+from numba.tests.support import TestCase, needs_subprocess
+import unittest
+
+
+@needs_subprocess
+class Test(TestCase):
+
+    def test(self):
+        @njit(debug=True)
+        def foo(x):
+            z = 7 + x # break here
+            return x, z
+
+        foo(120)
+
+        sz = types.intp.bitwidth
+        driver = GdbMIDriver(__file__)
+        driver.set_breakpoint(line=14)
+        driver.run()
+        driver.check_hit_breakpoint(1)
+        driver.stack_list_arguments(2)
+        expect = ('[frame={level="0",args=[{name="x",type="int%s",'
+                  'value="120"}]}]' % sz)
+        driver.assert_output(expect)
+        driver.stack_list_variables(1)
+        expect = '[{name="x",arg="1",value="120"},{name="z",value="0"}]'
+        driver.assert_output(expect)
+        driver.next()
+        driver.stack_list_variables(1)
+        expect = '[{name="x",arg="1",value="120"},{name="z",value="127"}]'
+        driver.assert_output(expect)
+        driver.quit()
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/gdb/test_break_on_symbol.py

@@ -0,0 +1,34 @@
+# NOTE: This test is sensitive to line numbers as it checks breakpoints
+from numba import njit, types
+from numba.tests.gdb_support import GdbMIDriver
+from numba.tests.support import TestCase, needs_subprocess
+import unittest
+
+
+@njit(debug=True)
+def foo(x):
+    z = 7 + x
+    return x, z
+
+
+@needs_subprocess
+class Test(TestCase):
+
+    def test(self):
+        foo(120)
+        sz = types.intp.bitwidth
+        driver = GdbMIDriver(__file__)
+        driver.set_breakpoint(symbol="__main__::foo")
+        driver.run() # will hit cpython symbol match
+        driver.check_hit_breakpoint(number=1)
+        driver.cont() # will hit njit symbol match
+        driver.check_hit_breakpoint(number=1, line=10) # Ensure line number
+        driver.stack_list_arguments(2)
+        expect = ('[frame={level="0",args=[{name="x",type="int%s",'
+                  'value="120"}]}]' % sz)
+        driver.assert_output(expect)
+        driver.quit()
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/gdb/test_break_on_symbol_version.py

@@ -0,0 +1,65 @@
+# NOTE: This test is sensitive to line numbers as it checks breakpoints
+from numba import njit
+from numba.tests.gdb_support import GdbMIDriver
+from numba.tests.support import TestCase, needs_subprocess
+import unittest
+
+
+def foo_factory(n):
+    @njit(debug=True)
+    def foo(x):
+        z = 7 + n
+        return x, z
+
+    return foo
+
+
+foo1, foo2, foo3 = [foo_factory(x) for x in range(3)]
+
+
+@njit(debug=True)
+def call_foo():
+    a = foo1(10)
+    b = foo2(20)
+    c = foo3(30)
+    return a, b, c
+
+
+@needs_subprocess
+class Test(TestCase):
+
+    def test(self):
+        call_foo()
+        driver = GdbMIDriver(__file__)
+        # A specific foo, the first one, it has uid=2
+        vsym = "__main__::foo_factory::_3clocals_3e::foo[abi:v2]"
+        driver.set_breakpoint(symbol=vsym)
+        driver.run()
+        driver.check_hit_breakpoint(number=1)
+        driver.assert_regex_output(r'^.*foo\[abi:v2\].*line="11"')
+        driver.stack_list_arguments(2)
+        expect = ('[frame={level="0",args=[{name="x",type="Literal[int](10)",'
+                  'value="10"}]}]')
+        driver.assert_output(expect)
+        # Now break on any foo
+        driver.set_breakpoint(symbol="foo")
+        driver.cont()
+        driver.check_hit_breakpoint(number=2)
+        driver.assert_regex_output(r'^.*foo\[abi:v3\].*line="11"')
+        driver.stack_list_arguments(2)
+        expect = ('[frame={level="0",args=[{name="x",type="Literal[int](20)",'
+                  'value="20"}]}]')
+        driver.assert_output(expect)
+        # and again, hit the third foo
+        driver.cont()
+        driver.check_hit_breakpoint(number=2)
+        driver.assert_regex_output(r'^.*foo\[abi:v4\].*line="11"')
+        driver.stack_list_arguments(2)
+        expect = ('[frame={level="0",args=[{name="x",type="Literal[int](30)",'
+                  'value="30"}]}]')
+        driver.assert_output(expect)
+        driver.quit()
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/gdb/test_conditional_breakpoint.py

@@ -0,0 +1,45 @@
+# NOTE: This test is sensitive to line numbers as it checks breakpoints
+from numba import njit
+from numba.tests.gdb_support import GdbMIDriver
+from numba.tests.support import TestCase, needs_subprocess
+import unittest
+
+
+@needs_subprocess
+class Test(TestCase):
+
+    def test(self):
+
+        @njit(debug=True)
+        def foo(x, y):
+            c = x + y  # break-here
+            return c
+
+        @njit(debug=True)
+        def call_foo(a):
+            acc = 0
+            for i in range(10):
+                acc += foo(i, a)
+            return acc
+
+        call_foo(10)
+
+        driver = GdbMIDriver(__file__)
+        driver.set_breakpoint(line=15, condition='x == 4')
+        driver.run()
+        driver.check_hit_breakpoint(1)
+        driver.stack_list_arguments(1)
+        expect = ('[frame={level="0",args=[{name="x",value="4"},'
+                  '{name="y",value="10"}]}]')
+        driver.assert_output(expect)
+        driver.set_breakpoint(line=22, condition='i == 8')
+        driver.cont()
+        driver.check_hit_breakpoint(2)
+        driver.stack_list_variables(1)
+        # i should be 8
+        driver.assert_output('{name="i",value="8"}')
+        driver.quit()
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/gdb/test_pretty_print.py

@@ -0,0 +1,69 @@
+# NOTE: This test is sensitive to line numbers as it checks breakpoints
+from numba import njit
+import numpy as np
+from numba.tests.gdb_support import GdbMIDriver, needs_gdb_py3
+from numba.tests.support import TestCase, needs_subprocess
+from numba.misc.numba_gdbinfo import collect_gdbinfo
+import unittest
+import re
+
+
+@needs_gdb_py3
+@needs_subprocess
+class Test(TestCase):
+
+    def test(self):
+        rdt_a = np.dtype([("x", np.int16), ("y", np.float64)], align=True)
+
+        @njit(debug=True)
+        def foo():
+            a = 1.234
+            b = (1, 2, 3)
+            c = ('a', b, 4)
+            d = np.arange(5.)
+            e = np.array([[1, 3j], [2, 4j]])
+            f = "Some string" + "           L-Padded string".lstrip()
+            g = 11 + 22j
+            h = np.arange(24).reshape((4, 6))[::2, ::3]
+            i = np.zeros(2, dtype=rdt_a)
+            return a, b, c, d, e, f, g, h, i
+
+        foo()
+
+        extension = collect_gdbinfo().extension_loc
+        driver = GdbMIDriver(__file__, init_cmds=['-x', extension], debug=False)
+        driver.set_breakpoint(line=29)
+        driver.run()
+        driver.check_hit_breakpoint(1)
+
+        # Ideally the function would be run to get the string repr of locals
+        # but not everything appears in DWARF e.g. string literals. Further,
+        # str on NumPy arrays seems to vary a bit in output. Therefore a custom
+        # match is used.
+
+        driver.stack_list_variables(1)
+        output = driver._captured.after.decode('UTF-8')
+        done_str = output.splitlines()[0]
+        pat = r'^\^done,variables=\[\{(.*)\}\]$'
+        lcls_strs = re.match(pat, done_str).groups()[0].split('},{')
+        lcls = {k: v for k, v in [re.match(r'name="(.*)",value="(.*)"',
+                x).groups() for x in lcls_strs]}
+        expected = dict()
+        expected['a'] = r'1\.234'
+        expected['b'] = r'\(1, 2, 3\)'
+        expected['c'] = r'\(0x0, \(1, 2, 3\), 4\)'
+        expected['d'] = r'\\n\[0. 1. 2. 3. 4.\]'
+        expected['e'] = r'\\n\[\[1.\+0.j 0.\+3.j\]\\n \[2.\+0.j 0.\+4.j\]\]'
+        expected['f'] = "'Some stringL-Padded string'"
+        expected['g'] = r"11\+22j"
+        expected['h'] = r'\\n\[\[ 0  3\]\\n \[12 15\]\]'
+        expected['i'] = r'\\n\[\(0, 0.\) \(0, 0.\)\]'
+
+        for k, v in expected.items():
+            self.assertRegex(lcls[k], v)
+
+        driver.quit()
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/inlining_usecases.py

@@ -0,0 +1,69 @@
+""" Test cases for inlining IR from another module """
+from numba import jit, njit
+from numba.core import types
+from numba.core.extending import overload
+
+_GLOBAL1 = 100
+
+
+@njit(inline='always')
+def bar():
+    return _GLOBAL1 + 10
+
+
+def baz_factory(a):
+    b = 17 + a
+
+    @njit(inline='always')
+    def baz():
+        return _GLOBAL1 + a - b
+    return baz
+
+
+def baz():
+    return _GLOBAL1 + 10
+
+
+@overload(baz, inline='always')
+def baz_ol():
+    def impl():
+        return _GLOBAL1 + 10
+    return impl
+
+
+def bop_factory(a):
+    b = 17 + a
+
+    def bop():
+        return _GLOBAL1 + a - b
+
+    @overload(bop, inline='always')
+    def baz():
+        def impl():
+            return _GLOBAL1 + a - b
+        return impl
+
+    return bop
+
+
+@jit((types.int32,), nopython=True)
+def inner(a):
+    return a + 1
+
+
+@jit((types.int32,), nopython=True)
+def more(a):
+    return inner(inner(a))
+
+
+def outer_simple(a):
+    return inner(a) * 2
+
+
+def outer_multiple(a):
+    return inner(a) * more(a)
+
+
+@njit
+def __dummy__():
+    return

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/__init__.py

@@ -0,0 +1,10 @@
+from os.path import dirname
+import unittest
+from unittest.suite import TestSuite
+
+from numba.testing import load_testsuite
+
+def load_tests(loader, tests, pattern):
+    suite = TestSuite()
+    suite.addTests(load_testsuite(loader, dirname(__file__)))
+    return suite

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/cache_usecases.py

@@ -0,0 +1,76 @@
+import numba as nb
+
+
+#
+# UFunc
+#
+
+def direct_ufunc_cache_usecase(**kwargs):
+    @nb.vectorize(["intp(intp)", "float64(float64)"], cache=True, **kwargs)
+    def ufunc(inp):
+        return inp * 2
+
+    return ufunc
+
+
+def indirect_ufunc_cache_usecase(**kwargs):
+    @nb.njit(cache=True)
+    def indirect_ufunc_core(inp):
+        return inp * 3
+
+    @nb.vectorize(["intp(intp)", "float64(float64)", "complex64(complex64)"],
+                  **kwargs)
+    def ufunc(inp):
+        return indirect_ufunc_core(inp)
+
+    return ufunc
+
+
+#
+# DUFunc
+#
+
+def direct_dufunc_cache_usecase(**kwargs):
+    @nb.vectorize(cache=True, **kwargs)
+    def ufunc(inp):
+        return inp * 2
+
+    return ufunc
+
+
+def indirect_dufunc_cache_usecase(**kwargs):
+    @nb.njit(cache=True)
+    def indirect_ufunc_core(inp):
+        return inp * 3
+
+    @nb.vectorize(**kwargs)
+    def ufunc(inp):
+        return indirect_ufunc_core(inp)
+
+    return ufunc
+
+
+#
+# GUFunc
+#
+
+def direct_gufunc_cache_usecase(**kwargs):
+    @nb.guvectorize(["(intp, intp[:])", "(float64, float64[:])"],
+                    "()->()", cache=True, **kwargs)
+    def gufunc(inp, out):
+        out[0] = inp * 2
+
+    return gufunc
+
+
+def indirect_gufunc_cache_usecase(**kwargs):
+    @nb.njit(cache=True)
+    def core(x):
+        return x * 3
+
+    @nb.guvectorize(["(intp, intp[:])", "(float64, float64[:])",
+                     "(complex64, complex64[:])"], "()->()", **kwargs)
+    def gufunc(inp, out):
+        out[0] = core(inp)
+
+    return gufunc

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/test_caching.py

@@ -0,0 +1,228 @@
+import sys
+import os.path
+import re
+import subprocess
+
+import numpy as np
+
+from numba.tests.support import capture_cache_log
+from numba.tests.test_caching import BaseCacheTest
+from numba.core import config
+import unittest
+
+
+class UfuncCacheTest(BaseCacheTest):
+    """
+    Since the cache stats is not exposed by ufunc, we test by looking at the
+    cache debug log.
+    """
+    _numba_parallel_test_ = False
+
+    here = os.path.dirname(__file__)
+    usecases_file = os.path.join(here, "cache_usecases.py")
+    modname = "ufunc_caching_test_fodder"
+
+    regex_data_saved = re.compile(r'\[cache\] data saved to')
+    regex_index_saved = re.compile(r'\[cache\] index saved to')
+
+    regex_data_loaded = re.compile(r'\[cache\] data loaded from')
+    regex_index_loaded = re.compile(r'\[cache\] index loaded from')
+
+    def check_cache_saved(self, cachelog, count):
+        """
+        Check number of cache-save were issued
+        """
+        data_saved = self.regex_data_saved.findall(cachelog)
+        index_saved = self.regex_index_saved.findall(cachelog)
+        self.assertEqual(len(data_saved), count)
+        self.assertEqual(len(index_saved), count)
+
+    def check_cache_loaded(self, cachelog, count):
+        """
+        Check number of cache-load were issued
+        """
+        data_loaded = self.regex_data_loaded.findall(cachelog)
+        index_loaded = self.regex_index_loaded.findall(cachelog)
+        self.assertEqual(len(data_loaded), count)
+        self.assertEqual(len(index_loaded), count)
+
+    def check_ufunc_cache(self, usecase_name, n_overloads, **kwargs):
+        """
+        Check number of cache load/save.
+        There should be one per overloaded version.
+        """
+        mod = self.import_module()
+        usecase = getattr(mod, usecase_name)
+        # New cache entry saved
+        with capture_cache_log() as out:
+            new_ufunc = usecase(**kwargs)
+        cachelog = out.getvalue()
+        self.check_cache_saved(cachelog, count=n_overloads)
+
+        # Use cached version
+        with capture_cache_log() as out:
+            cached_ufunc = usecase(**kwargs)
+        cachelog = out.getvalue()
+        self.check_cache_loaded(cachelog, count=n_overloads)
+
+        return new_ufunc, cached_ufunc
+
+
+class TestUfuncCacheTest(UfuncCacheTest):
+
+    def test_direct_ufunc_cache(self, **kwargs):
+        new_ufunc, cached_ufunc = self.check_ufunc_cache(
+            "direct_ufunc_cache_usecase", n_overloads=2, **kwargs)
+        # Test the cached and original versions
+        inp = np.random.random(10).astype(np.float64)
+        np.testing.assert_equal(new_ufunc(inp), cached_ufunc(inp))
+        inp = np.arange(10, dtype=np.intp)
+        np.testing.assert_equal(new_ufunc(inp), cached_ufunc(inp))
+
+    def test_direct_ufunc_cache_objmode(self):
+        self.test_direct_ufunc_cache(forceobj=True)
+
+    def test_direct_ufunc_cache_parallel(self):
+        self.test_direct_ufunc_cache(target='parallel')
+
+    def test_indirect_ufunc_cache(self, **kwargs):
+        new_ufunc, cached_ufunc = self.check_ufunc_cache(
+            "indirect_ufunc_cache_usecase", n_overloads=3, **kwargs)
+        # Test the cached and original versions
+        inp = np.random.random(10).astype(np.float64)
+        np.testing.assert_equal(new_ufunc(inp), cached_ufunc(inp))
+        inp = np.arange(10, dtype=np.intp)
+        np.testing.assert_equal(new_ufunc(inp), cached_ufunc(inp))
+
+    def test_indirect_ufunc_cache_parallel(self):
+        self.test_indirect_ufunc_cache(target='parallel')
+
+
+class TestDUfuncCacheTest(UfuncCacheTest):
+    # Note: DUFunc doesn't support parallel target yet
+
+    def check_dufunc_usecase(self, usecase_name):
+        mod = self.import_module()
+        usecase = getattr(mod, usecase_name)
+        # Create dufunc
+        with capture_cache_log() as out:
+            ufunc = usecase()
+        self.check_cache_saved(out.getvalue(), count=0)
+        # Compile & cache
+        with capture_cache_log() as out:
+            ufunc(np.arange(10))
+        self.check_cache_saved(out.getvalue(), count=1)
+        self.check_cache_loaded(out.getvalue(), count=0)
+        # Use cached
+        with capture_cache_log() as out:
+            ufunc = usecase()
+            ufunc(np.arange(10))
+        self.check_cache_loaded(out.getvalue(), count=1)
+
+    def test_direct_dufunc_cache(self):
+        # We don't test for objmode because DUfunc don't support it.
+        self.check_dufunc_usecase('direct_dufunc_cache_usecase')
+
+    def test_indirect_dufunc_cache(self):
+        self.check_dufunc_usecase('indirect_dufunc_cache_usecase')
+
+
+def _fix_raw_path(rstr):
+    if config.IS_WIN32:
+        rstr = rstr.replace(r'/', r'\\\\')
+    return rstr
+
+
+class TestGUfuncCacheTest(UfuncCacheTest):
+
+    def test_filename_prefix(self):
+        mod = self.import_module()
+        usecase = getattr(mod, "direct_gufunc_cache_usecase")
+        with capture_cache_log() as out:
+            usecase()
+        cachelog = out.getvalue()
+        # find number filename with "guf-" prefix
+        fmt1 = _fix_raw_path(r'/__pycache__/guf-{}')
+        prefixed = re.findall(fmt1.format(self.modname), cachelog)
+        fmt2 = _fix_raw_path(r'/__pycache__/{}')
+        normal = re.findall(fmt2.format(self.modname), cachelog)
+        # expecting 2 overloads
+        self.assertGreater(len(normal), 2)
+        # expecting equal number of wrappers and overloads cache entries
+        self.assertEqual(len(normal), len(prefixed))
+
+    def test_direct_gufunc_cache(self, **kwargs):
+        # 2 cache entry for the 2 overloads
+        # and 2 cache entry for the gufunc wrapper
+        new_ufunc, cached_ufunc = self.check_ufunc_cache(
+            "direct_gufunc_cache_usecase", n_overloads=2 + 2, **kwargs)
+        # Test the cached and original versions
+        inp = np.random.random(10).astype(np.float64)
+        np.testing.assert_equal(new_ufunc(inp), cached_ufunc(inp))
+        inp = np.arange(10, dtype=np.intp)
+        np.testing.assert_equal(new_ufunc(inp), cached_ufunc(inp))
+
+    def test_direct_gufunc_cache_objmode(self):
+        self.test_direct_gufunc_cache(forceobj=True)
+
+    def test_direct_gufunc_cache_parallel(self):
+        self.test_direct_gufunc_cache(target='parallel')
+
+    def test_indirect_gufunc_cache(self, **kwargs):
+        # 3 cache entry for the 3 overloads
+        # and no cache entry for the gufunc wrapper
+        new_ufunc, cached_ufunc = self.check_ufunc_cache(
+            "indirect_gufunc_cache_usecase", n_overloads=3, **kwargs)
+        # Test the cached and original versions
+        inp = np.random.random(10).astype(np.float64)
+        np.testing.assert_equal(new_ufunc(inp), cached_ufunc(inp))
+        inp = np.arange(10, dtype=np.intp)
+        np.testing.assert_equal(new_ufunc(inp), cached_ufunc(inp))
+
+    def test_indirect_gufunc_cache_parallel(self, **kwargs):
+        self.test_indirect_gufunc_cache(target='parallel')
+
+
+class TestCacheSpecificIssue(UfuncCacheTest):
+
+    def run_in_separate_process(self, runcode):
+        # Based on the same name util function in test_dispatcher but modified
+        # to allow user to define what to run.
+        code = """if 1:
+            import sys
+
+            sys.path.insert(0, %(tempdir)r)
+            mod = __import__(%(modname)r)
+            mod.%(runcode)s
+            """ % dict(tempdir=self.tempdir, modname=self.modname,
+                       runcode=runcode)
+
+        popen = subprocess.Popen([sys.executable, "-c", code],
+                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        out, err = popen.communicate()
+        if popen.returncode != 0:
+            raise AssertionError("process failed with code %s: stderr follows"
+                                 "\n%s\n" % (popen.returncode, err.decode()))
+
+    #
+    # The following test issue #2198 that loading cached (g)ufunc first
+    # bypasses some target context initialization.
+    #
+
+    def test_first_load_cached_ufunc(self):
+        # ensure function is cached
+        self.run_in_separate_process('direct_ufunc_cache_usecase()')
+        # use the cached function
+        # this will fail if the target context is not init'ed
+        self.run_in_separate_process('direct_ufunc_cache_usecase()')
+
+    def test_first_load_cached_gufunc(self):
+        # ensure function is cached
+        self.run_in_separate_process('direct_gufunc_cache_usecase()')
+        # use the cached function
+        # this will fail out if the target context is not init'ed
+        self.run_in_separate_process('direct_gufunc_cache_usecase()')
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/test_dufunc.py

@@ -0,0 +1,1139 @@
+import functools
+import itertools
+import pickle
+import textwrap
+import warnings
+
+import numpy as np
+
+from numba import njit, vectorize
+from numba.tests.support import MemoryLeakMixin, TestCase
+from numba.core.errors import (TypingError, NumbaNotImplementedError,
+                               NumbaExperimentalFeatureWarning)
+import unittest
+from numba.np.ufunc import dufunc
+from numba.np.numpy_support import from_dtype
+
+
+def pyuadd(a0, a1):
+    return a0 + a1
+
+
+def pysub(a0, a1):
+    return a0 - a1
+
+
+def pymult(a0, a1):
+    return a0 * a1
+
+
+def pydiv(a0, a1):
+    return a0 // a1
+
+
+def pymin(a0, a1):
+    return a0 if a0 < a1 else a1
+
+
+class TestDUFunc(MemoryLeakMixin, unittest.TestCase):
+
+    def nopython_dufunc(self, pyfunc):
+        return dufunc.DUFunc(pyfunc, targetoptions=dict(nopython=True))
+
+    def test_frozen(self):
+        duadd = self.nopython_dufunc(pyuadd)
+        self.assertFalse(duadd._frozen)
+        duadd._frozen = True
+        self.assertTrue(duadd._frozen)
+        with self.assertRaises(ValueError):
+            duadd._frozen = False
+        with self.assertRaises(TypeError):
+            duadd(np.linspace(0,1,10), np.linspace(1,2,10))
+
+    def test_scalar(self):
+        duadd = self.nopython_dufunc(pyuadd)
+        self.assertEqual(pyuadd(1,2), duadd(1,2))
+
+    def test_npm_call(self):
+        duadd = self.nopython_dufunc(pyuadd)
+
+        @njit
+        def npmadd(a0, a1, o0):
+            duadd(a0, a1, o0)
+        X = np.linspace(0,1.9,20)
+        X0 = X[:10]
+        X1 = X[10:]
+        out0 = np.zeros(10)
+        npmadd(X0, X1, out0)
+        np.testing.assert_array_equal(X0 + X1, out0)
+        Y0 = X0.reshape((2,5))
+        Y1 = X1.reshape((2,5))
+        out1 = np.zeros((2,5))
+        npmadd(Y0, Y1, out1)
+        np.testing.assert_array_equal(Y0 + Y1, out1)
+        Y2 = X1[:5]
+        out2 = np.zeros((2,5))
+        npmadd(Y0, Y2, out2)
+        np.testing.assert_array_equal(Y0 + Y2, out2)
+
+    def test_npm_call_implicit_output(self):
+        duadd = self.nopython_dufunc(pyuadd)
+
+        @njit
+        def npmadd(a0, a1):
+            return duadd(a0, a1)
+        X = np.linspace(0,1.9,20)
+        X0 = X[:10]
+        X1 = X[10:]
+        out0 = npmadd(X0, X1)
+        np.testing.assert_array_equal(X0 + X1, out0)
+        Y0 = X0.reshape((2,5))
+        Y1 = X1.reshape((2,5))
+        out1 = npmadd(Y0, Y1)
+        np.testing.assert_array_equal(Y0 + Y1, out1)
+        Y2 = X1[:5]
+        out2 = npmadd(Y0, Y2)
+        np.testing.assert_array_equal(Y0 + Y2, out2)
+        out3 = npmadd(1.,2.)
+        self.assertEqual(out3, 3.)
+
+    def test_ufunc_props(self):
+        duadd = self.nopython_dufunc(pyuadd)
+        self.assertEqual(duadd.nin, 2)
+        self.assertEqual(duadd.nout, 1)
+        self.assertEqual(duadd.nargs, duadd.nin + duadd.nout)
+        self.assertEqual(duadd.ntypes, 0)
+        self.assertEqual(duadd.types, [])
+        self.assertEqual(duadd.identity, None)
+        duadd(1, 2)
+        self.assertEqual(duadd.ntypes, 1)
+        self.assertEqual(duadd.ntypes, len(duadd.types))
+        self.assertIsNone(duadd.signature)
+
+    def test_ufunc_props_jit(self):
+        duadd = self.nopython_dufunc(pyuadd)
+        duadd(1, 2)  # initialize types attribute
+
+        attributes = {'nin': duadd.nin,
+                      'nout': duadd.nout,
+                      'nargs': duadd.nargs,
+                      #'ntypes': duadd.ntypes,
+                      #'types': duadd.types,
+                      'identity': duadd.identity,
+                      'signature': duadd.signature}
+
+        def get_attr_fn(attr):
+            fn = f'''
+                def impl():
+                    return duadd.{attr}
+            '''
+            l = {}
+            exec(textwrap.dedent(fn), {'duadd': duadd}, l)
+            return l['impl']
+
+        for attr, val in attributes.items():
+            cfunc = njit(get_attr_fn(attr))
+            self.assertEqual(val, cfunc(),
+                             f'Attribute differs from original: {attr}')
+
+        # We don't expose [n]types attributes as they are dynamic attributes
+        # and can change as the user calls the ufunc
+        # cfunc = njit(get_attr_fn('ntypes'))
+        # self.assertEqual(cfunc(), 1)
+        # duadd(1.1, 2.2)
+        # self.assertEqual(cfunc(), 2)
+
+
+class TestDUFuncMethodsBase(TestCase):
+
+    @functools.cache
+    def _generate_jit(self, ufunc, kind, identity=None):
+        assert kind in ('reduce', 'reduceat', 'at')
+        if kind == 'reduce':
+            if ufunc.nin == 2:
+                vec = vectorize(identity=identity)(lambda a, b: ufunc(a, b))
+            else:
+                vec = vectorize(identity=identity)(lambda a: ufunc(a))
+
+            @njit
+            def fn(array, axis=0, initial=None):
+                return vec.reduce(array, axis=axis, initial=initial)
+            return fn
+        elif kind == 'reduceat':
+            if ufunc.nin != 2:
+                raise ValueError('reduceat only supported for binary functions')
+            vec = vectorize(identity=identity)(lambda a, b: ufunc(a, b))
+
+            @njit
+            def fn(array, indices, axis=0, dtype=None, out=None):
+                return vec.reduceat(array, indices, axis, dtype, out)
+            return fn
+        else:
+            if ufunc.nin == 2:
+                vec = vectorize(identity=identity)(lambda a, b: ufunc(a, b))
+            else:
+                vec = vectorize(identity=identity)(lambda a: ufunc(a))
+
+            @njit
+            def fn(*args):
+                return vec.at(*args)
+            return fn
+
+    def _reduce(self, ufunc, identity):
+        return self._generate_jit(ufunc, 'reduce', identity=identity)
+
+    def _reduceat(self, ufunc, identity):
+        return self._generate_jit(ufunc, 'reduceat', identity=identity)
+
+    def _at(self, ufunc):
+        return self._generate_jit(ufunc, 'at')
+
+
+class TestDUFuncAt(TestDUFuncMethodsBase):
+    def _compare_output(self, fn, ufunc, a, *args):
+        expected = a.copy()
+        got = a.copy()
+        ufunc.at(expected, *args)
+        fn(got, *args)
+        self.assertPreciseEqual(expected, got)
+
+    def test_numpy_ufunc_at_basic(self):
+        # tests taken from: https://github.com/numpy/numpy/blob/27d8c43eb958b4ecee59b4d66908750759a9afc2/numpy/core/tests/test_ufunc.py#L1974-L2003  # noqa: E501
+        # NumPy also test this function with a Rational array dtype. We skip
+        # this test as Numba doesn't support Rational
+        a = np.arange(10, dtype=int)
+
+        add_at = self._at(np.add)
+        negative_at = self._at(np.negative)
+
+        negative_vec = vectorize()(lambda a: np.negative(a))
+
+        @njit
+        def negative_jit_2(a, indices, b):
+            return negative_vec.at(a, indices, b)
+
+        # basic testing
+        self._compare_output(add_at, np.add, a, [2, 5, 2], 1)
+
+        # missing second operand
+        err_msg = 'second operand needed for ufunc'
+        with self.assertRaisesRegex(TypingError, err_msg):
+            add_at(a.copy(), [2, 5, 3], None)
+
+        self._compare_output(negative_at, np.negative, a.copy(), [2, 5, 3])
+
+        b = np.array([100, 100, 100])
+        self._compare_output(add_at, np.add, a.copy(), [2, 5, 2], b)
+
+        # extraneous second operand
+        err_msg = 'second operand provided when ufunc is unary'
+        with self.assertRaisesRegex(TypingError, err_msg):
+            negative_jit_2(a.copy(), [2, 5, 3], [1, 2, 3])
+
+        with self.assertRaises(TypingError):
+            add_at(a.copy(), [2, 5, 3], [[1, 2], 1])
+
+    def test_ufunc_at_inner_loop(self):
+        typecodes = np.typecodes['Complex']
+        ufuncs = (np.add, np.subtract, np.multiply)
+        for typecode in typecodes:
+
+            try:
+                from_dtype(np.dtype(typecode))
+            except NumbaNotImplementedError:
+                continue
+
+            for ufunc in ufuncs:
+                a = np.ones(10, dtype=typecode)
+                indx = np.concatenate([np.ones(6, dtype=np.intp),
+                                       np.full(18, 4, dtype=np.intp)])
+                value = a.dtype.type(1j)
+                ufunc_at = self._at(ufunc)
+                ufunc_at(a, indx, value)
+                expected = np.ones_like(a)
+                if ufunc is np.multiply:
+                    expected[1] = expected[4] = -1
+                else:
+                    expected[1] += 6 * (value if ufunc is np.add else -value)
+                    expected[4] += 18 * (value if ufunc is np.add else -value)
+
+        self.assertPreciseEqual(a, expected)
+
+    def test_ufunc_at_ellipsis(self):
+        # Make sure the indexed loop check does not choke on iters
+        # with subspaces
+        arr = np.zeros(5, dtype=int)
+        add_at = self._at(np.add)
+        self._compare_output(add_at, np.add, arr, slice(None),
+                             np.ones(5, dtype=int))
+
+    def test_ufunc_at_negative(self):
+        arr = np.ones(5, dtype=np.int32)
+        indx = np.arange(5)
+        at = self._at(np.negative)
+        at(arr, indx)
+        assert np.all(arr == [-1, -1, -1, -1, -1])
+
+    def test_ufunc_at_large(self):
+        # NumPy issue gh-23457
+        indices = np.zeros(8195, dtype=np.int16)
+        b = np.zeros(8195, dtype=float)
+        b[0] = 10
+        b[1] = 5
+        b[8192:] = 100
+        a = np.zeros(1, dtype=float)
+        add_at = self._at(np.add)
+        add_at(a, indices, b)
+        assert a[0] == b.sum()
+
+    def test_cast_index_fastpath(self):
+        arr = np.zeros(10)
+        values = np.ones(100000)
+        add_at = self._at(np.add)
+        # index must be cast, which may be buffered in chunks:
+        index = np.zeros(len(values), dtype=np.uint8)
+        add_at(arr, index, values)
+        assert arr[0] == len(values)
+
+    def test_ufunc_at_scalar_value_fastpath(self):
+        values = (np.ones(1), np.ones(()), np.float64(1.), 1.)
+        for value in values:
+            arr = np.zeros(1000)
+            # index must be cast, which may be buffered in chunks:
+            index = np.repeat(np.arange(1000), 2)
+            add_at = self._at(np.add)
+            add_at(arr, index, value)
+            np.testing.assert_array_equal(arr, np.full_like(arr, 2 * value))
+
+    def test_ufunc_at_multiD(self):
+        a = np.arange(9).reshape(3, 3)
+        b = np.array([[100, 100, 100], [200, 200, 200], [300, 300, 300]])
+        add_at = self._at(np.add)
+        add_at(a, (slice(None), np.asarray([1, 2, 1])), b)
+        self.assertPreciseEqual(a, np.array(
+            [[0, 201, 102], [3, 404, 205], [6, 607, 308]]))
+
+        a = np.arange(27).reshape(3, 3, 3)
+        b = np.array([100, 200, 300])
+        add_at(a, (slice(None), slice(None), np.asarray([1, 2, 1])), b)
+        self.assertPreciseEqual(a, np.array(
+                                [[[0, 401, 202],
+                                  [3, 404, 205],
+                                  [6, 407, 208]],
+
+                                 [[9, 410, 211],
+                                  [12, 413, 214],
+                                  [15, 416, 217]],
+
+                                 [[18, 419, 220],
+                                  [21, 422, 223],
+                                  [24, 425, 226]]]))
+
+        a = np.arange(9).reshape(3, 3)
+        b = np.array([[100, 100, 100], [200, 200, 200], [300, 300, 300]])
+        add_at(a, (np.asarray([1, 2, 1]), slice(None)), b)
+        self.assertPreciseEqual(a, np.asarray(
+            [[0, 1, 2], [403, 404, 405], [206, 207, 208]]))
+
+        a = np.arange(27).reshape(3, 3, 3)
+        b = np.array([100, 200, 300])
+        add_at(a, (slice(None), np.asarray([1, 2, 1]), slice(None)), b)
+        self.assertPreciseEqual(a, np.asarray(
+                                [[[0,  1,  2],
+                                  [203, 404, 605],
+                                  [106, 207, 308]],
+
+                                 [[9,  10, 11],
+                                  [212, 413, 614],
+                                  [115, 216, 317]],
+
+                                 [[18, 19, 20],
+                                  [221, 422, 623],
+                                  [124, 225, 326]]]))
+
+        a = np.arange(9).reshape(3, 3)
+        b = np.array([100, 200, 300])
+        add_at(a, (0, np.asarray([1, 2, 1])), b)
+        self.assertPreciseEqual(a, np.asarray(
+            [[0, 401, 202], [3, 4, 5], [6, 7, 8]]))
+
+        a = np.arange(27).reshape(3, 3, 3)
+        b = np.array([100, 200, 300])
+        add_at(a, (np.asarray([1, 2, 1]), 0, slice(None)), b)
+        self.assertPreciseEqual(a, np.asarray(
+                                [[[0,  1,  2],
+                                  [3,  4,  5],
+                                  [6,  7,  8]],
+
+                                 [[209, 410, 611],
+                                  [12,  13, 14],
+                                  [15,  16, 17]],
+
+                                 [[118, 219, 320],
+                                  [21,  22, 23],
+                                  [24,  25, 26]]]))
+
+        a = np.arange(27).reshape(3, 3, 3)
+        b = np.array([100, 200, 300])
+        add_at = self._at(np.add)
+        add_at(a, (slice(None), slice(None), slice(None)), b)
+        self.assertPreciseEqual(a, np.asarray(
+                                [[[100, 201, 302],
+                                  [103, 204, 305],
+                                  [106, 207, 308]],
+
+                                 [[109, 210, 311],
+                                  [112, 213, 314],
+                                  [115, 216, 317]],
+
+                                 [[118, 219, 320],
+                                  [121, 222, 323],
+                                  [124, 225, 326]]]))
+
+    def test_ufunc_at_0D(self):
+        a = np.array(0)
+        add_at = self._at(np.add)
+        add_at(a, (), 1)
+        self.assertPreciseEqual(a, np.array(1))
+
+        with self.assertRaises(TypingError):
+            add_at(a, 0, 1)
+
+        b = np.arange(3)
+        add_at(b, 0, 1)
+        self.assertPreciseEqual(b, np.array([1, 1, 2]))
+
+        # NumPy checks for IndexError but we can't call a jit function with an
+        # empty list as Numba raises "can't compute fingerprint of empty list"
+        with self.assertRaises(ValueError):
+            add_at(a, [], 1)
+
+    def test_ufunc_at_dtypes(self):
+        # Test mixed dtypes
+        a = np.arange(10)
+        power_at = self._at(np.power)
+        power_at(a, [1, 2, 3, 2], 3.5)
+        self.assertPreciseEqual(a, np.array([0, 1, 4414, 46, 4, 5, 6, 7, 8, 9]))
+
+    def test_ufunc_at_boolean(self):
+        # Test boolean indexing and boolean ufuncs
+        a = np.arange(10)
+        index = a % 2 == 0
+        equal_at = self._at(np.equal)
+        # boolean indexing not supported
+        equal_at(a, index, [0, 2, 4, 6, 8])
+        self.assertPreciseEqual(a, np.array([1, 1, 1, 3, 1, 5, 1, 7, 1, 9]))
+
+    def test_ufunc_at_boolean2(self):
+        # Test unary operator
+        a = np.arange(10, dtype='u4')
+        invert_at = self._at(np.invert)
+        invert_at(a, [2, 5, 2])
+        self.assertPreciseEqual(a, np.array([0, 1, 2, 3, 4, 5 ^ 0xffffffff, 6,
+                                             7, 8, 9], dtype=np.uint32))
+
+    def test_ufunc_at_advanced(self):
+        # Test empty subspace
+        orig = np.arange(4)
+        a = orig[:, None][:, 0:0]
+        add_at = self._at(np.add)
+        add_at(a, [0, 1], 3)
+        self.assertPreciseEqual(orig, np.arange(4))
+
+    @unittest.expectedFailure
+    def test_ufunc_at_advanced_2(self):
+        # Test with swapped byte order
+        index = np.array([1, 2, 1], np.dtype('i').newbyteorder())
+        values = np.array([1, 2, 3, 4], np.dtype('f').newbyteorder())
+        add_at = self._at(np.add)
+        add_at(values, index, 3)
+        self.assertPreciseEqual(values, [1, 8, 6, 4])
+
+    def test_ufunc_at_advanced_3(self):
+        # Test exception thrown
+        values = np.array(['a', 1], dtype=object)
+        add_at = self._at(np.add)
+        with self.assertRaises(TypingError):
+            add_at(values, [0, 1], 1)
+        self.assertPreciseEqual(values, np.array(['a', 1], dtype=object))
+
+    def test_ufunc_at_advanced_4(self):
+        # Test multiple output ufuncs raise error, NumPy gh-5665
+        modf_at = self._at(np.modf)
+        # NumPy raises ValueError as modf returns multiple outputs
+        with self.assertRaises(TypingError):
+            modf_at(np.arange(10), [1])
+
+    def test_ufunc_at_advanced_5(self):
+        # Test maximum
+        maximum_at = self._at(np.maximum)
+        a = np.array([1, 2, 3])
+        maximum_at(a, [0], 0)
+        self.assertPreciseEqual(a, np.array([1, 2, 3]))
+
+    def test_ufunc_at_negative_indexes(self):
+        dtypes = np.typecodes['AllInteger'] + np.typecodes['Float']
+        ufuncs = (np.add, np.subtract, np.divide, np.minimum, np.maximum)
+
+        for dtype in dtypes:
+
+            if dtype in ('e',):  # skip float16 as we don't have an impl. for it
+                continue
+
+            try:
+                from_dtype(np.dtype(dtype))
+            except NumbaNotImplementedError:
+                continue
+
+            for ufunc in ufuncs:
+                a = np.arange(0, 10).astype(dtype)
+                indxs = np.array([-1, 1, -1, 2]).astype(np.intp)
+                vals = np.array([1, 5, 2, 10], dtype=a.dtype)
+
+                expected = a.copy()
+                for i, v in zip(indxs, vals):
+                    expected[i] = ufunc(expected[i], v)
+
+                ufunc_at = self._at(ufunc)
+                ufunc_at(a, indxs, vals)
+                np.testing.assert_array_equal(a, expected)
+                assert np.all(indxs == [-1, 1, -1, 2])
+
+    @unittest.expectedFailure
+    def test_ufunc_at_not_none_signature(self):
+        # Test ufuncs with non-trivial signature raise a TypeError
+        a = np.ones((2, 2, 2))
+        b = np.ones((1, 2, 2))
+        # matmul is a gufunc, thus, this will fail atm
+        matmul_at = self._at(np.matmul)
+        err_msg = 'does not support ufunc with non-trivial signature'
+        with self.assertRaisesRegex(TypingError, err_msg):
+            matmul_at(a, [0], b)
+
+        # a = np.array([[[1, 2], [3, 4]]])
+        # assert_raises(TypeError, np.linalg._umath_linalg.det.at, a, [0])
+
+    def test_ufunc_at_no_loop_for_op(self):
+        # str dtype does not have a ufunc loop for np.add
+        arr = np.ones(10, dtype=str)
+        add_at = self._at(np.add)
+        # NumPy raises `np.core._exceptions._UFuncNoLoopError`
+        with self.assertRaises(TypingError):
+            add_at(arr, [0, 1], [0, 1])
+
+    def test_ufunc_at_output_casting(self):
+        arr = np.array([-1])
+        equal_at = self._at(np.equal)
+        equal_at(arr, [0], [0])
+        assert arr[0] == 0
+
+    def test_ufunc_at_broadcast_failure(self):
+        arr = np.arange(5)
+        add_at = self._at(np.add)
+
+        # NumPy raises ValueError('array is not broadcastable to correct shape')
+        msg = 'operands could not be broadcast together with remapped shapes'
+        with self.assertRaisesRegex(ValueError, msg):
+            add_at(arr, [0, 1], [1, 2, 3])
+
+    def test_ufunc_at_dynamic(self):
+        arr = np.arange(5)
+
+        @vectorize
+        def inc(x):
+            return x + 1
+
+        self.assertEqual(len(inc.types), 0)
+
+        # trying to call inc.at should trigger compilation
+        inc.at(arr, [1, 3])
+
+        self.assertGreater(len(inc.types), 0)
+
+    def test_ufunc_at_experimental_warning(self):
+        arr = np.arange(5)
+        add_at = self._at(np.add)
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter('always', NumbaExperimentalFeatureWarning)
+
+            add_at(arr, [0, 3], 10)
+
+        self.assertGreater(len(w), 0)
+        self.assertIn('ufunc.at feature is experimental', str(w[0].message))
+
+
+class TestDUFuncReduceNumPyTests(TestCase):
+    # Tests taken from
+    # https://github.com/numpy/numpy/blob/51ee17b6bd4ccec60a5483ee8bff94ad0c0e8585/numpy/_core/tests/test_ufunc.py  # noqa: E501
+
+    def _generate_jit(self, ufunc, identity=None):
+        if ufunc.nin == 2:
+            vec = vectorize(identity=identity)(lambda a, b: ufunc(a, b))
+        else:
+            vec = vectorize(identity=identity)(lambda a: ufunc(a))
+
+        @njit
+        def fn(array, axis=0, initial=None):
+            return vec.reduce(array, axis=axis, initial=initial)
+        return fn
+
+    @unittest.expectedFailure
+    def test_numpy_scalar_reduction(self):
+        # scalar reduction is not supported
+        power_reduce = self._generate_jit(np.power)
+        expected = np.power.reduce(3)
+        got = power_reduce(3)
+        self.assertPreciseEqual(expected, got)
+
+    def check_identityless_reduction(self, a):
+        def compare_output(a, b):
+            # We don't use self.assertPreciseEqual as the dtype differs
+            # between the value from the reduction and the hardcoded output
+            np.testing.assert_equal(a, b)
+        # test taken from:
+        # https://github.com/numpy/numpy/blob/51ee17b6bd4ccec60a5483ee8bff94ad0c0e8585/numpy/_core/tests/test_ufunc.py#L1591  # noqa: E501
+
+        minimum_reduce = self._generate_jit(np.minimum, identity='reorderable')
+
+        # np.minimum.reduce is an identityless reduction
+
+        # Verify that it sees the zero at various positions
+        a[...] = 1
+        a[1, 0, 0] = 0
+        compare_output(minimum_reduce(a, axis=None), 0)
+        compare_output(minimum_reduce(a, axis=(0, 1)), [0, 1, 1, 1])
+        compare_output(minimum_reduce(a, axis=(0, 2)), [0, 1, 1])
+        compare_output(minimum_reduce(a, axis=(1, 2)), [1, 0])
+        compare_output(minimum_reduce(a, axis=0),
+                       [[0, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]])
+        compare_output(minimum_reduce(a, axis=1),
+                       [[1, 1, 1, 1], [0, 1, 1, 1]])
+        compare_output(minimum_reduce(a, axis=2),
+                       [[1, 1, 1], [0, 1, 1]])
+        compare_output(minimum_reduce(a, axis=()), a)
+
+        a[...] = 1
+        a[0, 1, 0] = 0
+        compare_output(minimum_reduce(a, axis=None), 0)
+        compare_output(minimum_reduce(a, axis=(0, 1)), [0, 1, 1, 1])
+        compare_output(minimum_reduce(a, axis=(0, 2)), [1, 0, 1])
+        compare_output(minimum_reduce(a, axis=(1, 2)), [0, 1])
+        compare_output(minimum_reduce(a, axis=0),
+                       [[1, 1, 1, 1], [0, 1, 1, 1], [1, 1, 1, 1]])
+        compare_output(minimum_reduce(a, axis=1),
+                       [[0, 1, 1, 1], [1, 1, 1, 1]])
+        compare_output(minimum_reduce(a, axis=2),
+                       [[1, 0, 1], [1, 1, 1]])
+        compare_output(minimum_reduce(a, axis=()), a)
+
+        a[...] = 1
+        a[0, 0, 1] = 0
+        compare_output(minimum_reduce(a, axis=None), 0)
+        compare_output(minimum_reduce(a, axis=(0, 1)), [1, 0, 1, 1])
+        compare_output(minimum_reduce(a, axis=(0, 2)), [0, 1, 1])
+        compare_output(minimum_reduce(a, axis=(1, 2)), [0, 1])
+        compare_output(minimum_reduce(a, axis=0),
+                       [[1, 0, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]])
+        compare_output(minimum_reduce(a, axis=1),
+                       [[1, 0, 1, 1], [1, 1, 1, 1]])
+        compare_output(minimum_reduce(a, axis=2),
+                       [[0, 1, 1], [1, 1, 1]])
+        compare_output(minimum_reduce(a, axis=()), a)
+
+    def test_numpy_identityless_reduction_corder(self):
+        a = np.empty((2, 3, 4), order='C')
+        self.check_identityless_reduction(a)
+
+    def test_numpy_identityless_reduction_forder(self):
+        a = np.empty((2, 3, 4), order='F')
+        self.check_identityless_reduction(a)
+
+    def test_numpy_identityless_reduction_otherorder(self):
+        a = np.empty((2, 4, 3), order='C').swapaxes(1, 2)
+        self.check_identityless_reduction(a)
+
+    def test_numpy_identityless_reduction_noncontig(self):
+        a = np.empty((3, 5, 4), order='C').swapaxes(1, 2)
+        a = a[1:, 1:, 1:]
+        self.check_identityless_reduction(a)
+
+    def test_numpy_identityless_reduction_noncontig_unaligned(self):
+        a = np.empty((3 * 4 * 5 * 8 + 1,), dtype='i1')
+        a = a[1:].view(dtype='f8')
+        a = a.reshape((3, 4, 5))
+        a = a[1:, 1:, 1:]
+        self.check_identityless_reduction(a)
+
+    def test_numpy_initial_reduction(self):
+        # np.minimum.reduce is an identityless reduction
+        add_reduce = self._generate_jit(np.add)
+        min_reduce = self._generate_jit(np.minimum)
+        max_reduce = self._generate_jit(np.maximum)
+
+        # For cases like np.maximum(np.abs(...), initial=0)
+        # More generally, a supremum over non-negative numbers.
+        self.assertPreciseEqual(max_reduce(np.asarray([]), initial=0), 0.0)
+
+        # For cases like reduction of an empty array over the reals.
+        self.assertPreciseEqual(min_reduce(np.asarray([]), initial=np.inf),
+                                np.inf)
+        self.assertPreciseEqual(max_reduce(np.asarray([]), initial=-np.inf),
+                                -np.inf)
+
+        # Random tests
+        self.assertPreciseEqual(min_reduce(np.asarray([5]), initial=4), 4)
+        self.assertPreciseEqual(max_reduce(np.asarray([4]), initial=5), 5)
+        self.assertPreciseEqual(max_reduce(np.asarray([5]), initial=4), 5)
+        self.assertPreciseEqual(min_reduce(np.asarray([4]), initial=5), 4)
+
+        # Check initial=None raises ValueError for both types of ufunc
+        # reductions
+        msg = 'zero-size array to reduction operation'
+        for func in (add_reduce, min_reduce):
+            with self.assertRaisesRegex(ValueError, msg):
+                func(np.asarray([]), initial=None)
+
+    def test_numpy_empty_reduction_and_identity(self):
+        arr = np.zeros((0, 5))
+        true_divide_reduce = self._generate_jit(np.true_divide)
+
+        # OK, since the reduction itself is *not* empty, the result is
+        expected = np.true_divide.reduce(arr, axis=1)
+        got = true_divide_reduce(arr, axis=1)
+        self.assertPreciseEqual(expected, got)
+        self.assertPreciseEqual(got.shape, (0,))
+
+        # Not OK, the reduction itself is empty and we have no identity
+        msg = 'zero-size array to reduction operation'
+        with self.assertRaisesRegex(ValueError, msg):
+            true_divide_reduce(arr, axis=0)
+
+        # Test that an empty reduction fails also if the result is empty
+        arr = np.zeros((0, 0, 5))
+        with self.assertRaisesRegex(ValueError, msg):
+            true_divide_reduce(arr, axis=1)
+
+        # Division reduction makes sense with `initial=1` (empty or not):
+        expected = np.true_divide.reduce(arr, axis=1, initial=1)
+        got = true_divide_reduce(arr, axis=1, initial=1)
+        self.assertPreciseEqual(expected, got)
+
+    def test_identityless_reduction_nonreorderable(self):
+        a = np.array([[8.0, 2.0, 2.0], [1.0, 0.5, 0.25]])
+
+        divide_reduce = self._generate_jit(np.divide)
+        res = divide_reduce(a, axis=0)
+        self.assertPreciseEqual(res, np.asarray([8.0, 4.0, 8.0]))
+
+        res = divide_reduce(a, axis=1)
+        self.assertPreciseEqual(res, np.asarray([2.0, 8.0]))
+
+        res = divide_reduce(a, axis=())
+        self.assertPreciseEqual(res, a)
+
+        # will not raise as per Numba issue #9283
+        # assert_raises(ValueError, np.divide.reduce, a, axis=(0, 1))
+
+    def test_reduce_zero_axis(self):
+        # If we have a n x m array and do a reduction with axis=1, then we are
+        # doing n reductions, and each reduction takes an m-element array. For
+        # a reduction operation without an identity, then:
+        #   n > 0, m > 0: fine
+        #   n = 0, m > 0: fine, doing 0 reductions of m-element arrays
+        #   n > 0, m = 0: can't reduce a 0-element array, ValueError
+        #   n = 0, m = 0: can't reduce a 0-element array, ValueError (for
+        #     consistency with the above case)
+        # This test doesn't actually look at return values, it just checks to
+        # make sure that error we get an error in exactly those cases where we
+        # expect one, and assumes the calculations themselves are done
+        # correctly.
+
+        def ok(f, *args, **kwargs):
+            f(*args, **kwargs)
+
+        def err(f, *args, **kwargs):
+            with self.assertRaises(ValueError):
+                f(*args, **kwargs)
+
+        def t(expect, func, n, m):
+            expect(func, np.zeros((n, m)), axis=1)
+            expect(func, np.zeros((m, n)), axis=0)
+            expect(func, np.zeros((n // 2, n // 2, m)), axis=2)
+            expect(func, np.zeros((n // 2, m, n // 2)), axis=1)
+            expect(func, np.zeros((n, m // 2, m // 2)), axis=(1, 2))
+            expect(func, np.zeros((m // 2, n, m // 2)), axis=(0, 2))
+            expect(func, np.zeros((m // 3, m // 3, m // 3,
+                                   n // 2, n // 2)), axis=(0, 1, 2))
+            # Check what happens if the inner (resp. outer) dimensions are a
+            # mix of zero and non-zero:
+            expect(func, np.zeros((10, m, n)), axis=(0, 1))
+            expect(func, np.zeros((10, n, m)), axis=(0, 2))
+            expect(func, np.zeros((m, 10, n)), axis=0)
+            expect(func, np.zeros((10, m, n)), axis=1)
+            expect(func, np.zeros((10, n, m)), axis=2)
+
+        # np.maximum is just an arbitrary ufunc with no reduction identity
+        maximum_reduce = self._generate_jit(np.maximum, identity='reorderable')
+        self.assertEqual(np.maximum.identity, None)
+        t(ok, maximum_reduce, 30, 30)
+        t(ok, maximum_reduce, 0, 30)
+        t(err, maximum_reduce, 30, 0)
+        t(err, maximum_reduce, 0, 0)
+        err(maximum_reduce, [])
+        maximum_reduce(np.zeros((0, 0)), axis=())
+
+        # all of the combinations are fine for a reduction that has an
+        # identity
+        add_reduce = self._generate_jit(np.add, identity=0)
+        t(ok, add_reduce, 30, 30)
+        t(ok, add_reduce, 0, 30)
+        t(ok, add_reduce, 30, 0)
+        t(ok, add_reduce, 0, 0)
+        add_reduce(np.array([], dtype=np.int64))
+        add_reduce(np.zeros((0, 0)), axis=())
+
+
+class TestDUFuncReduce(TestDUFuncMethodsBase):
+    def _check_reduce(self, ufunc, dtype=None, initial=None):
+
+        @njit
+        def foo(a, axis, dtype, initial):
+            return ufunc.reduce(a,
+                                axis=axis,
+                                dtype=dtype,
+                                initial=initial)
+
+        inputs = [
+            np.arange(5),
+            np.arange(4).reshape(2, 2),
+            np.arange(40).reshape(5, 4, 2),
+        ]
+        for array in inputs:
+            for axis in range(array.ndim):
+                expected = foo.py_func(array, axis, dtype, initial)
+                got = foo(array, axis, dtype, initial)
+                self.assertPreciseEqual(expected, got)
+
+    def _check_reduce_axis(self, ufunc, dtype, initial=None):
+
+        @njit
+        def foo(a, axis):
+            return ufunc.reduce(a, axis=axis, initial=initial)
+
+        def _check(*args):
+            try:
+                expected = foo.py_func(array, axis)
+            except ValueError as e:
+                self.assertEqual(e.args[0], exc_msg)
+                with self.assertRaisesRegex(TypingError, exc_msg):
+                    got = foo(array, axis)
+            else:
+                got = foo(array, axis)
+                self.assertPreciseEqual(expected, got)
+
+        exc_msg = (f"reduction operation '{ufunc.__name__}' is not "
+                   "reorderable, so at most one axis may be specified")
+        inputs = [
+            np.arange(40, dtype=dtype).reshape(5, 4, 2),
+            np.arange(10, dtype=dtype),
+        ]
+        for array in inputs:
+            for i in range(1, array.ndim + 1):
+                for axis in itertools.combinations(range(array.ndim), r=i):
+                    _check(array, axis)
+
+            # corner cases: Reduce over axis=() and axis=None
+            for axis in ((), None):
+                _check(array, axis)
+
+    def test_add_reduce(self):
+        duadd = vectorize('int64(int64, int64)', identity=0)(pyuadd)
+        self._check_reduce(duadd)
+        self._check_reduce_axis(duadd, dtype=np.int64)
+
+    def test_mul_reduce(self):
+        dumul = vectorize('int64(int64, int64)', identity=1)(pymult)
+        self._check_reduce(dumul)
+
+    def test_non_associative_reduce(self):
+        dusub = vectorize('int64(int64, int64)', identity=None)(pysub)
+        dudiv = vectorize('int64(int64, int64)', identity=None)(pydiv)
+        self._check_reduce(dusub)
+        self._check_reduce_axis(dusub, dtype=np.int64)
+        self._check_reduce(dudiv)
+        self._check_reduce_axis(dudiv, dtype=np.int64)
+
+    def test_reduce_dtype(self):
+        duadd = vectorize('float64(float64, int64)', identity=0)(pyuadd)
+        self._check_reduce(duadd, dtype=np.float64)
+
+    def test_min_reduce(self):
+        dumin = vectorize('int64(int64, int64)', identity='reorderable')(pymin)
+        self._check_reduce(dumin, initial=10)
+        self._check_reduce_axis(dumin, dtype=np.int64)
+
+    def test_add_reduce_initial(self):
+        # Initial should be used as a start
+        duadd = vectorize('int64(int64, int64)', identity=0)(pyuadd)
+        self._check_reduce(duadd, dtype=np.int64, initial=100)
+
+    def test_add_reduce_no_initial_or_identity(self):
+        # don't provide an initial or identity value
+        duadd = vectorize('int64(int64, int64)')(pyuadd)
+        self._check_reduce(duadd, dtype=np.int64)
+
+    def test_invalid_input(self):
+        duadd = vectorize('float64(float64, int64)', identity=0)(pyuadd)
+
+        @njit
+        def foo(a):
+            return duadd.reduce(a)
+
+        exc_msg = 'The first argument "array" must be array-like'
+        with self.assertRaisesRegex(TypingError, exc_msg):
+            foo('a')
+
+    def test_dufunc_negative_axis(self):
+        duadd = vectorize('int64(int64, int64)', identity=0)(pyuadd)
+
+        @njit
+        def foo(a, axis):
+            return duadd.reduce(a, axis=axis)
+
+        a = np.arange(40).reshape(5, 4, 2)
+        cases = (0, -1, (0, -1), (-1, -2), (1, -1), -3)
+        for axis in cases:
+            expected = duadd.reduce(a, axis)
+            got = foo(a, axis)
+            self.assertPreciseEqual(expected, got)
+
+    def test_dufunc_invalid_axis(self):
+        duadd = vectorize('int64(int64, int64)', identity=0)(pyuadd)
+
+        @njit
+        def foo(a, axis):
+            return duadd.reduce(a, axis=axis)
+
+        a = np.arange(40).reshape(5, 4, 2)
+        cases = ((0, 0), (0, 1, 0), (0, -3), (-1, -1), (-1, 2))
+        for axis in cases:
+            msg = "duplicate value in 'axis'"
+            with self.assertRaisesRegex(ValueError, msg):
+                foo(a, axis)
+
+        cases = (-4, 3, (0, -4),)
+        for axis in cases:
+            with self.assertRaisesRegex(ValueError, "Invalid axis"):
+                foo(a, axis)
+
+
+class TestDUFuncReduceAt(TestDUFuncMethodsBase):
+    def _compare_output(self, ufunc, a, idx, **kwargs):
+        identity = getattr(ufunc, 'identity')
+        fn = self._reduceat(ufunc, identity)
+        expected = a.copy()
+        got = a.copy()
+        ufunc.reduceat(expected, idx, **kwargs)
+        fn(got, idx, **kwargs)
+        self.assertPreciseEqual(expected, got)
+
+    def test_reduceat_out_kw(self):
+        arr = np.arange(4)
+        idx = np.asarray([0, 3, 1, 2])
+        add_reduce = self._reduceat(np.add, 0)
+        add_reduce(arr, idx, out=arr)
+        self.assertPreciseEqual(np.asarray([3, 3, 3, 6]), arr)
+        add_reduce(arr, idx, out=arr)
+        self.assertPreciseEqual(np.asarray([9, 6, 6, 12]), arr)
+
+    @unittest.expectedFailure
+    def test_reduceat_axis_kw(self):
+        arrays = (
+            np.arange(16).reshape(4, 4),
+            np.arange(40).reshape(4, 5, 2),
+            np.ones((4, 4))
+        )
+        indices = (
+            np.asarray([0, 3, 1, 2, 0]),
+            np.asarray([0, 3, 1, 2]),
+        )
+        axis = (1, 0, -1)  # needs gh-9296
+        for array in arrays:
+            for idx in indices:
+                for ax in axis:
+                    self._compare_output(np.add, array, idx, axis=ax)
+
+    def test_reduceat_invalid_axis(self):
+        arr = np.ones((4, 4))
+        idx = np.asarray([0, 3, 1, 2])
+        add_reduceat = self._reduceat(np.add, 0)
+
+        for ax in (2, -3):  # needs gh-9296
+            msg = (f'axis {ax} is out of bounds for array of dimension '
+                   f'{arr.ndim}')
+            with self.assertRaisesRegex(ValueError, msg):
+                add_reduceat(arr, idx, ax)
+
+    def test_reduceat_cast_args_to_array(self):
+        add_reduceat = self._reduceat(np.add, 0)
+
+        # cast array and indices
+        a = [1, 2, 3, 4]
+        idx = [1, 2, 3]
+        expected = np.add.reduceat(a, idx)
+        got = add_reduceat(a, idx)
+        self.assertPreciseEqual(expected, got)
+
+        # array and indices as tuples
+        a = (1, 2, 3, 4)
+        idx = (1, 2, 3)
+        expected = np.add.reduceat(a, idx)
+        got = add_reduceat(a, idx)
+        self.assertPreciseEqual(expected, got)
+
+    # tests below this line were copied from NumPy
+    # https://github.com/numpy/numpy/blob/7f8dc13b9bcaa26cb378b9c8246110ca1dc9ce75/numpy/_core/tests/test_ufunc.py#L200C1-L200C1  # noqa: E501
+    def test_reduceat_basic(self):
+        x = np.arange(8)
+        idx = [0,4, 1,5, 2,6, 3,7]
+        self._compare_output(np.add, x, idx)
+
+    def test_reduceat_basic_2d(self):
+        x = np.linspace(0, 15, 16).reshape(4, 4)
+        idx = [0, 3, 1, 2, 0]
+        self._compare_output(np.add, x, idx)
+
+    def test_reduceat_shifting_sum(self):
+        L = 6
+        x = np.arange(L)
+        idx = np.array(list(zip(np.arange(L - 2), np.arange(L - 2) + 2))).ravel()  # noqa: E501
+        self._compare_output(np.add, x, idx)
+
+    def test_reduceat_int_array_reduceat_inplace(self):
+        # Checks that in-place reduceats work, see also gh-7465
+        arr = np.ones(4, dtype=np.int64)
+        out = np.ones(4, dtype=np.int64)
+        self._compare_output(np.add, arr, np.arange(4), out=arr)
+        self._compare_output(np.add, arr, np.arange(4), out=arr)
+        self.assertPreciseEqual(arr, out)
+
+        # needs gh-9296
+        # And the same if the axis argument is used
+        arr = np.ones((2, 4), dtype=np.int64)
+        arr[0, :] = [2 for i in range(4)]
+        out = np.ones((2, 4), dtype=np.int64)
+        out[0, :] = [2 for i in range(4)]
+        self._compare_output(np.add, arr, np.arange(4), out=arr, axis=-1)
+        self._compare_output(np.add, arr, np.arange(4), out=arr, axis=-1)
+        self.assertPreciseEqual(arr, out)
+
+    def test_reduceat_out_shape_mismatch(self):
+        # Should raise an error mentioning "shape" or "size"
+        # original test has an extra step for accumulate but we don't support
+        # it yet
+        add_reduceat = self._reduceat(np.add, 0)
+
+        for with_cast in (True, False):
+            arr = np.arange(5)
+            out = np.arange(3)  # definitely wrong shape
+            if with_cast:
+                # If a cast is necessary on the output, we can be sure to use
+                # the generic NpyIter (non-fast) path.
+                out = out.astype(np.float64)
+
+            with self.assertRaises(ValueError):
+                add_reduceat(arr, [0, 3], out=out)
+
+    def test_reduceat_empty(self):
+        """Reduceat should work with empty arrays"""
+        indices = np.array([], 'i4')
+        x = np.array([], 'f8')
+        add_reduceat = self._reduceat(np.add, 0)
+        expected = np.add.reduceat(x, indices)
+        got = add_reduceat(x, indices)
+        self.assertPreciseEqual(expected, got)
+        self.assertEqual(expected.dtype, got.dtype)
+
+        # Another case with a slightly different zero-sized shape
+        x = np.ones((5, 2))
+        idx = np.asarray([], dtype=np.intp)
+        self._compare_output(np.add, x, idx, axis=0)
+        self._compare_output(np.add, x, idx, axis=1)
+
+    def test_reduceat_error_ndim_2(self):
+        add_reduceat = self._reduceat(np.add, 0)
+
+        # indices ndim > 1
+        a = np.arange(5)
+        idx = np.arange(10).reshape(5, 2)
+        with self.assertRaisesRegex(TypingError, 'have at most 1 dimension'):
+            add_reduceat(a, idx)
+
+    def test_reduceat_error_non_binary_function(self):
+        # non binary functions
+        @vectorize
+        def neg(a):
+            return np.negative(a)
+
+        @njit
+        def neg_reduceat(a, idx):
+            return neg.reduceat(a, idx)
+
+        a = np.arange(5)
+        msg = 'reduceat only supported for binary functions'
+        with self.assertRaisesRegex(TypingError, msg):
+            neg_reduceat(a, [0, 1, 2])
+
+    def test_reduceat_error_argument_types(self):
+        # first argument must be array-like
+        add_reduceat = self._reduceat(np.add, 0)
+        with self.assertRaisesRegex(TypingError, '"array" must be array-like'):
+            add_reduceat('abc', [1, 2, 3])
+
+        with self.assertRaisesRegex(TypingError, '"indices" must be array-like'):  # noqa: E501
+            add_reduceat(np.arange(5), 'abcd')
+
+        with self.assertRaisesRegex(TypingError, 'output must be an array'):
+            add_reduceat(np.arange(5), [1, 2, 3], out=())
+
+        with self.assertRaisesRegex(TypingError, '"axis" must be an integer'):
+            add_reduceat(np.arange(5), [1, 2, 3], axis=(1,))
+
+
+class TestDUFuncPickling(MemoryLeakMixin, unittest.TestCase):
+    def check(self, ident, result_type):
+        buf = pickle.dumps(ident)
+        rebuilt = pickle.loads(buf)
+
+        # Check reconstructed dufunc
+        r = rebuilt(123)
+        self.assertEqual(123, r)
+        self.assertIsInstance(r, result_type)
+
+        # Try to use reconstructed dufunc in @jit
+        @njit
+        def foo(x):
+            return rebuilt(x)
+
+        r = foo(321)
+        self.assertEqual(321, r)
+        self.assertIsInstance(r, result_type)
+
+    def test_unrestricted(self):
+        @vectorize
+        def ident(x1):
+            return x1
+
+        self.check(ident, result_type=(int, np.integer))
+
+    def test_restricted(self):
+        @vectorize(["float64(float64)"])
+        def ident(x1):
+            return x1
+
+        self.check(ident, result_type=float)
+
+
+if __name__ == "__main__":
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/test_errors.py

@@ -0,0 +1,174 @@
+import contextlib
+import sys
+
+import numpy as np
+
+from numba import vectorize, guvectorize
+
+from numba.tests.support import (TestCase, CheckWarningsMixin,
+                                 skip_macos_fenv_errors)
+import unittest
+
+
+def sqrt(val):
+    if val < 0.0:
+        raise ValueError('Value must be positive')
+    return val ** 0.5
+
+
+def gufunc_foo(inp, n, out):
+    for i in range(inp.shape[0]):
+        if inp[i] < 0:
+            raise ValueError('Value must be positive')
+        out[i] = inp[i] * n[0]
+
+def truediv(a, b):
+    return a / b
+
+def floordiv(a, b):
+    return a // b
+
+def remainder(a, b):
+    return a % b
+
+def power(a, b):
+    return a ** b
+
+
+class TestExceptions(TestCase):
+    """
+    Test raising exceptions inside ufuncs.
+    """
+
+    def check_ufunc_raise(self, **vectorize_args):
+        f = vectorize(['float64(float64)'], **vectorize_args)(sqrt)
+        arr = np.array([1, 4, -2, 9, -1, 16], dtype=np.float64)
+        out = np.zeros_like(arr)
+        with self.assertRaises(ValueError) as cm:
+            f(arr, out)
+        self.assertIn('Value must be positive', str(cm.exception))
+        # All values were computed except for the ones giving an error
+        self.assertEqual(list(out), [1, 2, 0, 3, 0, 4])
+
+    def test_ufunc_raise(self):
+        self.check_ufunc_raise(nopython=True)
+
+    def test_ufunc_raise_objmode(self):
+        self.check_ufunc_raise(forceobj=True)
+
+    def check_gufunc_raise(self, **vectorize_args):
+        f = guvectorize(['int32[:], int32[:], int32[:]'], '(n),()->(n)',
+                        **vectorize_args)(gufunc_foo)
+        arr = np.array([1, 2, -3, 4], dtype=np.int32)
+        out = np.zeros_like(arr)
+        with self.assertRaises(ValueError) as cm:
+            f(arr, 2, out)
+        # The gufunc bailed out after the error
+        self.assertEqual(list(out), [2, 4, 0, 0])
+
+    def test_gufunc_raise(self):
+        self.check_gufunc_raise(nopython=True)
+
+    def test_gufunc_raise_objmode(self):
+        self.check_gufunc_raise(forceobj=True)
+
+class TestFloatingPointExceptions(TestCase, CheckWarningsMixin):
+    """
+    Test floating-point exceptions inside ufuncs.
+
+    Note the warnings emitted by Numpy reflect IEEE-754 semantics.
+    """
+
+    def check_truediv_real(self, dtype):
+        """
+        Test 1 / 0 and 0 / 0.
+        """
+        f = vectorize(nopython=True)(truediv)
+        a = np.array([5., 6., 0., 8.], dtype=dtype)
+        b = np.array([1., 0., 0., 4.], dtype=dtype)
+        expected = np.array([5., float('inf'), float('nan'), 2.])
+        with self.check_warnings(["divide by zero encountered",
+                                  "invalid value encountered"]):
+            res = f(a, b)
+            self.assertPreciseEqual(res, expected)
+
+    def test_truediv_float(self):
+        self.check_truediv_real(np.float64)
+
+    def test_truediv_integer(self):
+        self.check_truediv_real(np.int32)
+
+    def check_divmod_float(self, pyfunc, values, messages):
+        """
+        Test 1 // 0 and 0 // 0.
+        """
+        f = vectorize(nopython=True)(pyfunc)
+        a = np.array([5., 6., 0., 9.])
+        b = np.array([1., 0., 0., 4.])
+        expected = np.array(values)
+        with self.check_warnings(messages):
+            res = f(a, b)
+            self.assertPreciseEqual(res, expected)
+
+    def test_floordiv_float(self):
+        self.check_divmod_float(floordiv,
+                                [5.0, float('inf'), float('nan'), 2.0],
+                                ["divide by zero encountered",
+                                 "invalid value encountered"])
+
+    @skip_macos_fenv_errors
+    def test_remainder_float(self):
+        self.check_divmod_float(remainder,
+                                [0.0, float('nan'), float('nan'), 1.0],
+                                ["invalid value encountered"])
+
+    def check_divmod_int(self, pyfunc, values):
+        """
+        Test 1 % 0 and 0 % 0.
+        """
+        f = vectorize(nopython=True)(pyfunc)
+        a = np.array([5, 6, 0, 9])
+        b = np.array([1, 0, 0, 4])
+        expected = np.array(values)
+        # No warnings raised because LLVM makes it difficult
+        with self.check_warnings([]):
+            res = f(a, b)
+            self.assertPreciseEqual(res, expected)
+
+    def test_floordiv_int(self):
+        self.check_divmod_int(floordiv, [5, 0, 0, 2])
+
+    def test_remainder_int(self):
+        self.check_divmod_int(remainder, [0, 0, 0, 1])
+
+    def test_power_float(self):
+        """
+        Test 0 ** -1 and 2 ** <big number>.
+        """
+        f = vectorize(nopython=True)(power)
+        a = np.array([5., 0., 2., 8.])
+        b = np.array([1., -1., 1e20, 4.])
+        expected = np.array([5., float('inf'), float('inf'), 4096.])
+        with self.check_warnings(["divide by zero encountered",
+                                  "overflow encountered"]):
+            res = f(a, b)
+            self.assertPreciseEqual(res, expected)
+
+    def test_power_integer(self):
+        """
+        Test 0 ** -1.
+        Note 2 ** <big number> returns an undefined value (depending
+        on the algorithm).
+        """
+        dtype = np.int64
+        f = vectorize(["int64(int64, int64)"], nopython=True)(power)
+        a = np.array([5, 0, 6], dtype=dtype)
+        b = np.array([1, -1, 2], dtype=dtype)
+        expected = np.array([5, -2**63, 36], dtype=dtype)
+        with self.check_warnings([]):
+            res = f(a, b)
+            self.assertPreciseEqual(res, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/test_gufunc.py

@@ -0,0 +1,870 @@
+import unittest
+import pickle
+
+import numpy as np
+
+from numba import void, float32, float64, int32, int64, jit, guvectorize
+from numba.core.errors import TypingError
+from numba.np.ufunc import GUVectorize
+from numba.tests.support import TestCase, MemoryLeakMixin
+
+
+def matmulcore(A, B, C):
+    """docstring for matmulcore"""
+    m, n = A.shape
+    n, p = B.shape
+    for i in range(m):
+        for j in range(p):
+            C[i, j] = 0
+            for k in range(n):
+                C[i, j] += A[i, k] * B[k, j]
+
+
+def axpy(a, x, y, out):
+    out[0] = a * x  + y
+
+
+class TestGUFunc(MemoryLeakMixin, TestCase):
+    target = 'cpu'
+
+    def check_matmul_gufunc(self, gufunc):
+        matrix_ct = 1001
+        A = np.arange(matrix_ct * 2 * 4, dtype=np.float32).reshape(matrix_ct, 2, 4)
+        B = np.arange(matrix_ct * 4 * 5, dtype=np.float32).reshape(matrix_ct, 4, 5)
+
+        C = gufunc(A, B)
+        Gold = np.matmul(A, B)
+
+        np.testing.assert_allclose(C, Gold, rtol=1e-5, atol=1e-8)
+
+    def test_gufunc(self):
+        gufunc = GUVectorize(matmulcore, '(m,n),(n,p)->(m,p)',
+                             target=self.target)
+        gufunc.add((float32[:, :], float32[:, :], float32[:, :]))
+        gufunc = gufunc.build_ufunc()
+
+        self.check_matmul_gufunc(gufunc)
+
+    def test_guvectorize_decor(self):
+        gufunc = guvectorize([void(float32[:,:], float32[:,:], float32[:,:])],
+                             '(m,n),(n,p)->(m,p)',
+                             target=self.target)(matmulcore)
+
+        self.check_matmul_gufunc(gufunc)
+
+    def test_ufunc_like(self):
+        # Test problem that the stride of "scalar" gufunc argument not properly
+        # handled when the actual argument is an array,
+        # causing the same value (first value) being repeated.
+        gufunc = GUVectorize(axpy, '(), (), () -> ()', target=self.target)
+        gufunc.add('(intp, intp, intp, intp[:])')
+        gufunc = gufunc.build_ufunc()
+
+        x = np.arange(10, dtype=np.intp)
+        out = gufunc(x, x, x)
+
+        np.testing.assert_equal(out, x * x + x)
+
+    def test_axis(self):
+        # issue https://github.com/numba/numba/issues/6773
+        @guvectorize(["f8[:],f8[:]"], "(n)->(n)")
+        def my_cumsum(x, res):
+            acc = 0
+            for i in range(x.shape[0]):
+                acc += x[i]
+                res[i] = acc
+
+        x = np.ones((20, 30))
+        # Check regular call
+        y = my_cumsum(x, axis=0)
+        expected = np.cumsum(x, axis=0)
+        np.testing.assert_equal(y, expected)
+        # Check "out" kw
+        out_kw = np.zeros_like(y)
+        my_cumsum(x, out=out_kw, axis=0)
+        np.testing.assert_equal(out_kw, expected)
+
+    def test_docstring(self):
+        @guvectorize([(int64[:], int64, int64[:])], '(n),()->(n)')
+        def gufunc(x, y, res):
+            "docstring for gufunc"
+            for i in range(x.shape[0]):
+                res[i] = x[i] + y
+
+        self.assertEqual("numba.tests.npyufunc.test_gufunc", gufunc.__module__)
+        self.assertEqual("gufunc", gufunc.__name__)
+        self.assertEqual("TestGUFunc.test_docstring.<locals>.gufunc", gufunc.__qualname__)
+        self.assertEqual("docstring for gufunc", gufunc.__doc__)
+
+
+class TestMultipleOutputs(MemoryLeakMixin, TestCase):
+    target = 'cpu'
+
+    def test_multiple_outputs_same_type_passed_in(self):
+        @guvectorize('(x)->(x),(x)',
+                     target=self.target)
+        def copy(A, B, C):
+            for i in range(B.size):
+                B[i] = A[i]
+                C[i] = A[i]
+
+        A = np.arange(10, dtype=np.float32) + 1
+        B = np.zeros_like(A)
+        C = np.zeros_like(A)
+        copy(A, B, C)
+        np.testing.assert_allclose(A, B)
+        np.testing.assert_allclose(A, C)
+
+    def test_multiple_outputs_distinct_values(self):
+
+        @guvectorize('(x)->(x),(x)',
+                     target=self.target)
+        def copy_and_double(A, B, C):
+            for i in range(B.size):
+                B[i] = A[i]
+                C[i] = A[i] * 2
+
+        A = np.arange(10, dtype=np.float32) + 1
+        B = np.zeros_like(A)
+        C = np.zeros_like(A)
+        copy_and_double(A, B, C)
+        np.testing.assert_allclose(A, B)
+        np.testing.assert_allclose(A * 2, C)
+
+    def test_multiple_output_dtypes(self):
+
+        @guvectorize('(x)->(x),(x)',
+                     target=self.target)
+        def copy_and_multiply(A, B, C):
+            for i in range(B.size):
+                B[i] = A[i]
+                C[i] = A[i] * 1.5
+
+        A = np.arange(10, dtype=np.int32) + 1
+        B = np.zeros_like(A)
+        C = np.zeros_like(A, dtype=np.float64)
+        copy_and_multiply(A, B, C)
+        np.testing.assert_allclose(A, B)
+        np.testing.assert_allclose(A * np.float64(1.5), C)
+
+    def test_incorrect_number_of_pos_args(self):
+        @guvectorize('(m),(m)->(m),(m)', target=self.target)
+        def f(x, y, z, w):
+            pass
+
+        arr = np.arange(5, dtype=np.int32)
+
+        # Inputs only, too few
+        msg = "Too few arguments for function 'f'"
+        with self.assertRaises(TypeError) as te:
+            f(arr)
+        self.assertIn(msg, str(te.exception))
+
+        # Inputs and outputs, too many
+        with self.assertRaises(TypeError) as te:
+            f(arr, arr, arr, arr, arr)
+        self.assertIn(msg, str(te.exception))
+
+
+class TestGUFuncParallel(TestGUFunc):
+    _numba_parallel_test_ = False
+    target = 'parallel'
+
+
+class TestDynamicGUFunc(MemoryLeakMixin, TestCase):
+    target = 'cpu'
+
+    def test_dynamic_matmul(self):
+
+        def check_matmul_gufunc(gufunc, A, B, C):
+            Gold = np.matmul(A, B)
+            gufunc(A, B, C)
+            np.testing.assert_allclose(C, Gold, rtol=1e-5, atol=1e-8)
+
+        gufunc = GUVectorize(matmulcore, '(m,n),(n,p)->(m,p)',
+                             target=self.target, is_dynamic=True)
+        matrix_ct = 10
+        Ai64 = np.arange(matrix_ct * 2 * 4, dtype=np.int64).reshape(matrix_ct, 2, 4)
+        Bi64 = np.arange(matrix_ct * 4 * 5, dtype=np.int64).reshape(matrix_ct, 4, 5)
+        Ci64 = np.arange(matrix_ct * 2 * 5, dtype=np.int64).reshape(matrix_ct, 2, 5)
+        check_matmul_gufunc(gufunc, Ai64, Bi64, Ci64)
+
+        A = np.arange(matrix_ct * 2 * 4, dtype=np.float32).reshape(matrix_ct, 2, 4)
+        B = np.arange(matrix_ct * 4 * 5, dtype=np.float32).reshape(matrix_ct, 4, 5)
+        C = np.arange(matrix_ct * 2 * 5, dtype=np.float32).reshape(matrix_ct, 2, 5)
+        check_matmul_gufunc(gufunc, A, B, C)  # trigger compilation
+
+        self.assertEqual(len(gufunc.types), 2)  # ensure two versions of gufunc
+
+
+    def test_dynamic_ufunc_like(self):
+
+        def check_ufunc_output(gufunc, x):
+            out = np.zeros(10, dtype=x.dtype)
+            out_kw = np.zeros(10, dtype=x.dtype)
+            gufunc(x, x, x, out)
+            gufunc(x, x, x, out=out_kw)
+            golden = x * x + x
+            np.testing.assert_equal(out, golden)
+            np.testing.assert_equal(out_kw, golden)
+
+        # Test problem that the stride of "scalar" gufunc argument not properly
+        # handled when the actual argument is an array,
+        # causing the same value (first value) being repeated.
+        gufunc = GUVectorize(axpy, '(), (), () -> ()', target=self.target,
+                             is_dynamic=True)
+        x = np.arange(10, dtype=np.intp)
+        check_ufunc_output(gufunc, x)
+
+
+    def test_dynamic_scalar_output(self):
+        """
+        Note that scalar output is a 0-dimension array that acts as
+        a pointer to the output location.
+        """
+
+        @guvectorize('(n)->()', target=self.target, nopython=True)
+        def sum_row(inp, out):
+            tmp = 0.
+            for i in range(inp.shape[0]):
+                tmp += inp[i]
+            out[()] = tmp
+
+        # inp is (10000, 3)
+        # out is (10000)
+        # The outer (leftmost) dimension must match or numpy broadcasting is performed.
+
+        self.assertTrue(sum_row.is_dynamic)
+        inp = np.arange(30000, dtype=np.int32).reshape(10000, 3)
+        out = np.zeros(10000, dtype=np.int32)
+        sum_row(inp, out)
+
+        # verify result
+        for i in range(inp.shape[0]):
+            self.assertEqual(out[i], inp[i].sum())
+
+        msg = "Too few arguments for function 'sum_row'."
+        with self.assertRaisesRegex(TypeError, msg):
+            sum_row(inp)
+
+    def test_axis(self):
+        # issue https://github.com/numba/numba/issues/6773
+        @guvectorize("(n)->(n)")
+        def my_cumsum(x, res):
+            acc = 0
+            for i in range(x.shape[0]):
+                acc += x[i]
+                res[i] = acc
+
+        x = np.ones((20, 30))
+        expected = np.cumsum(x, axis=0)
+        # Check regular call
+        y = np.zeros_like(expected)
+        my_cumsum(x, y, axis=0)
+        np.testing.assert_equal(y, expected)
+        # Check "out" kw
+        out_kw = np.zeros_like(y)
+        my_cumsum(x, out=out_kw, axis=0)
+        np.testing.assert_equal(out_kw, expected)
+
+    def test_gufunc_attributes(self):
+        @guvectorize("(n)->(n)")
+        def gufunc(x, res):
+            acc = 0
+            for i in range(x.shape[0]):
+                acc += x[i]
+                res[i] = acc
+
+        # ensure gufunc exports attributes
+        attrs = ['signature', 'accumulate', 'at', 'outer', 'reduce', 'reduceat']
+        for attr in attrs:
+            contains = hasattr(gufunc, attr)
+            self.assertTrue(contains, 'dynamic gufunc not exporting "%s"' % (attr,))
+
+        a = np.array([1, 2, 3, 4])
+        res = np.array([0, 0, 0, 0])
+        gufunc(a, res)  # trigger compilation
+        self.assertPreciseEqual(res, np.array([1, 3, 6, 10]))
+
+        # other attributes are not callable from a gufunc with signature
+        # see: https://github.com/numba/numba/issues/2794
+        # note: this is a limitation in NumPy source code!
+        self.assertEqual(gufunc.signature, "(n)->(n)")
+
+        with self.assertRaises(RuntimeError) as raises:
+            gufunc.accumulate(a)
+        self.assertEqual(str(raises.exception), "Reduction not defined on ufunc with signature")
+
+        with self.assertRaises(RuntimeError) as raises:
+            gufunc.reduce(a)
+        self.assertEqual(str(raises.exception), "Reduction not defined on ufunc with signature")
+
+        with self.assertRaises(RuntimeError) as raises:
+            gufunc.reduceat(a, [0, 2])
+        self.assertEqual(str(raises.exception), "Reduction not defined on ufunc with signature")
+
+        with self.assertRaises(TypeError) as raises:
+            gufunc.outer(a, a)
+        self.assertEqual(str(raises.exception), "method outer is not allowed in ufunc with non-trivial signature")
+
+    def test_gufunc_attributes2(self):
+        @guvectorize('(),()->()')
+        def add(x, y, res):
+            res[0] = x + y
+
+        # add signature "(),() -> ()" is evaluated to None
+        self.assertIsNone(add.signature)
+
+        a = np.array([1, 2, 3, 4])
+        b = np.array([4, 3, 2, 1])
+        res = np.array([0, 0, 0, 0])
+        add(a, b, res)  # trigger compilation
+        self.assertPreciseEqual(res, np.array([5, 5, 5, 5]))
+
+        # now test other attributes
+        self.assertIsNone(add.signature)
+        self.assertEqual(add.reduce(a), 10)
+        self.assertPreciseEqual(add.accumulate(a), np.array([1, 3, 6, 10]))
+        self.assertPreciseEqual(add.outer([0, 1], [1, 2]), np.array([[1, 2], [2, 3]]))
+        self.assertPreciseEqual(add.reduceat(a, [0, 2]), np.array([3, 7]))
+
+        x = np.array([1, 2, 3, 4])
+        y = np.array([1, 2])
+        add.at(x, [0, 1], y)
+        self.assertPreciseEqual(x, np.array([2, 4, 3, 4]))
+
+
+class TestGUVectorizeScalar(MemoryLeakMixin, TestCase):
+    """
+    Nothing keeps user from out-of-bound memory access
+    """
+    target = 'cpu'
+
+    def test_scalar_output(self):
+        """
+        Note that scalar output is a 0-dimension array that acts as
+        a pointer to the output location.
+        """
+
+        @guvectorize(['void(int32[:], int32[:])'], '(n)->()',
+                     target=self.target, nopython=True)
+        def sum_row(inp, out):
+            tmp = 0.
+            for i in range(inp.shape[0]):
+                tmp += inp[i]
+            out[()] = tmp
+
+        # inp is (10000, 3)
+        # out is (10000)
+        # The outer (leftmost) dimension must match or numpy broadcasting is performed.
+
+        inp = np.arange(30000, dtype=np.int32).reshape(10000, 3)
+        out = sum_row(inp)
+
+        # verify result
+        for i in range(inp.shape[0]):
+            self.assertEqual(out[i], inp[i].sum())
+
+    def test_scalar_input(self):
+
+        @guvectorize(['int32[:], int32[:], int32[:]'], '(n),()->(n)',
+                     target=self.target, nopython=True)
+        def foo(inp, n, out):
+            for i in range(inp.shape[0]):
+                out[i] = inp[i] * n[0]
+
+        inp = np.arange(3 * 10, dtype=np.int32).reshape(10, 3)
+        # out = np.empty_like(inp)
+        out = foo(inp, 2)
+
+        # verify result
+        self.assertPreciseEqual(inp * 2, out)
+
+    def test_scalar_input_core_type(self):
+        def pyfunc(inp, n, out):
+            for i in range(inp.size):
+                out[i] = n * (inp[i] + 1)
+
+        my_gufunc = guvectorize(['int32[:], int32, int32[:]'],
+                                '(n),()->(n)',
+                                target=self.target)(pyfunc)
+
+        # test single core loop execution
+        arr = np.arange(10).astype(np.int32)
+        got = my_gufunc(arr, 2)
+
+        expected = np.zeros_like(got)
+        pyfunc(arr, 2, expected)
+
+        np.testing.assert_equal(got, expected)
+
+        # test multiple core loop execution
+        arr = np.arange(20).astype(np.int32).reshape(10, 2)
+        got = my_gufunc(arr, 2)
+
+        expected = np.zeros_like(got)
+        for ax in range(expected.shape[0]):
+            pyfunc(arr[ax], 2, expected[ax])
+
+        np.testing.assert_equal(got, expected)
+
+    def test_scalar_input_core_type_error(self):
+        with self.assertRaises(TypeError) as raises:
+            @guvectorize(['int32[:], int32, int32[:]'], '(n),(n)->(n)',
+                         target=self.target)
+            def pyfunc(a, b, c):
+                pass
+        self.assertEqual("scalar type int32 given for non scalar argument #2",
+                         str(raises.exception))
+
+    def test_ndim_mismatch(self):
+        with self.assertRaises(TypeError) as raises:
+            @guvectorize(['int32[:], int32[:]'], '(m,n)->(n)',
+                         target=self.target)
+            def pyfunc(a, b):
+                pass
+        self.assertEqual("type and shape signature mismatch for arg #1",
+                         str(raises.exception))
+
+
+class TestGUVectorizeScalarParallel(TestGUVectorizeScalar):
+    _numba_parallel_test_ = False
+    target = 'parallel'
+
+
+class TestGUVectorizePickling(MemoryLeakMixin, TestCase):
+    def test_pickle_gufunc_non_dyanmic(self):
+        """Non-dynamic gufunc.
+        """
+        @guvectorize(["f8,f8[:]"], "()->()")
+        def double(x, out):
+            out[:] = x * 2
+
+        # pickle
+        ser = pickle.dumps(double)
+        cloned = pickle.loads(ser)
+
+        # attributes carried over
+        self.assertEqual(cloned._frozen, double._frozen)
+        self.assertEqual(cloned.identity, double.identity)
+        self.assertEqual(cloned.is_dynamic, double.is_dynamic)
+        self.assertEqual(cloned.gufunc_builder._sigs,
+                         double.gufunc_builder._sigs)
+        # expected value of attributes
+        self.assertTrue(cloned._frozen)
+
+        cloned.disable_compile()
+        self.assertTrue(cloned._frozen)
+
+        # scalar version
+        self.assertPreciseEqual(double(0.5), cloned(0.5))
+        # array version
+        arr = np.arange(10)
+        self.assertPreciseEqual(double(arr), cloned(arr))
+
+    def test_pickle_gufunc_dyanmic_null_init(self):
+        """Dynamic gufunc w/o prepopulating before pickling.
+        """
+        @guvectorize("()->()", identity=1)
+        def double(x, out):
+            out[:] = x * 2
+
+        # pickle
+        ser = pickle.dumps(double)
+        cloned = pickle.loads(ser)
+
+        # attributes carried over
+        self.assertEqual(cloned._frozen, double._frozen)
+        self.assertEqual(cloned.identity, double.identity)
+        self.assertEqual(cloned.is_dynamic, double.is_dynamic)
+        self.assertEqual(cloned.gufunc_builder._sigs,
+                         double.gufunc_builder._sigs)
+        # expected value of attributes
+        self.assertFalse(cloned._frozen)
+
+        # scalar version
+        expect = np.zeros(1)
+        got = np.zeros(1)
+        double(0.5, out=expect)
+        cloned(0.5, out=got)
+        self.assertPreciseEqual(expect, got)
+        # array version
+        arr = np.arange(10)
+        expect = np.zeros_like(arr)
+        got = np.zeros_like(arr)
+        double(arr, out=expect)
+        cloned(arr, out=got)
+        self.assertPreciseEqual(expect, got)
+
+    def test_pickle_gufunc_dynamic_initialized(self):
+        """Dynamic gufunc prepopulated before pickling.
+
+        Once unpickled, we disable compilation to verify that the gufunc
+        compilation state is carried over.
+        """
+        @guvectorize("()->()", identity=1)
+        def double(x, out):
+            out[:] = x * 2
+
+        # prepopulate scalar
+        expect = np.zeros(1)
+        got = np.zeros(1)
+        double(0.5, out=expect)
+        # prepopulate array
+        arr = np.arange(10)
+        expect = np.zeros_like(arr)
+        got = np.zeros_like(arr)
+        double(arr, out=expect)
+
+        # pickle
+        ser = pickle.dumps(double)
+        cloned = pickle.loads(ser)
+
+        # attributes carried over
+        self.assertEqual(cloned._frozen, double._frozen)
+        self.assertEqual(cloned.identity, double.identity)
+        self.assertEqual(cloned.is_dynamic, double.is_dynamic)
+        self.assertEqual(cloned.gufunc_builder._sigs,
+                         double.gufunc_builder._sigs)
+        # expected value of attributes
+        self.assertFalse(cloned._frozen)
+
+        # disable compilation
+        cloned.disable_compile()
+        self.assertTrue(cloned._frozen)
+        # scalar version
+        expect = np.zeros(1)
+        got = np.zeros(1)
+        double(0.5, out=expect)
+        cloned(0.5, out=got)
+        self.assertPreciseEqual(expect, got)
+        # array version
+        expect = np.zeros_like(arr)
+        got = np.zeros_like(arr)
+        double(arr, out=expect)
+        cloned(arr, out=got)
+        self.assertPreciseEqual(expect, got)
+
+
+class TestGUVectorizeJit(MemoryLeakMixin, TestCase):
+    target = 'cpu'
+
+    def check_add_gufunc(self, gufunc):
+        @jit(nopython=True)
+        def jit_add(x, y, res):
+            gufunc(x, y, res)
+
+        x = np.arange(40, dtype='i8').reshape(4, 2, 5)
+        y = np.int32(100)
+        res = np.zeros_like(x)
+        jit_add(x, y, res)
+        self.assertPreciseEqual(res, x + y)
+
+    def test_add_static(self):
+        @guvectorize('int64[:], int64, int64[:]', '(n),()->(n)',
+                     target=self.target)
+        def add(x, y, res):
+            for i in range(x.shape[0]):
+                res[i] = x[i] + y
+
+        self.check_add_gufunc(add)
+
+    def test_add_static_cast_args(self):
+        # cast the second argument from i32 -> i64
+        @guvectorize('int64[:], int64, int64[:]', '(n),()->(n)',
+                     target=self.target)
+        def add(x, y, res):
+            for i in range(x.shape[0]):
+                res[i] = x[i] + y
+
+        self.check_add_gufunc(add)
+
+    def test_add_dynamic(self):
+        @guvectorize('(n),()->(n)', target=self.target)
+        def add(x, y, res):
+            for i in range(x.shape[0]):
+                res[i] = x[i] + y
+
+        self.check_add_gufunc(add)
+
+    @unittest.expectedFailure
+    def test_object_mode(self):
+        @guvectorize('(n),()->(n)', target=self.target, forceobj=True)
+        def add(x, y, res):
+            for i in range(x.shape[0]):
+                res[i] = x[i] + y
+
+        self.check_add_gufunc(add)
+
+    def check_matmul(self, jit_func):
+        matrix_ct = 1001
+        A = np.arange(matrix_ct * 2 * 4, dtype=np.float32).reshape(matrix_ct, 2, 4)
+        B = np.arange(matrix_ct * 4 * 5, dtype=np.float32).reshape(matrix_ct, 4, 5)
+        C = np.arange(matrix_ct * 2 * 5, dtype=np.float32).reshape(matrix_ct, 2, 5)
+
+        jit_func(A, B, C)
+        Gold = np.matmul(A, B)
+
+        np.testing.assert_allclose(C, Gold, rtol=1e-5, atol=1e-8)
+
+    def test_njit_matmul_call(self):
+
+        gufunc = guvectorize('(m,n),(n,p)->(m,p)',
+                             target=self.target)(matmulcore)
+
+        @jit(nopython=True)
+        def matmul_jit(A, B, C):
+            return gufunc(A, B, C)
+
+        self.check_matmul(matmul_jit)
+
+    def test_axpy(self):
+        gufunc = GUVectorize(axpy, '(),(),() -> ()', target=self.target,
+                             is_dynamic=True)
+
+        @jit(nopython=True)
+        def axpy_jit(a, x, y, out):
+            gufunc(a, x, y, out)
+
+        x = np.arange(10, dtype=np.intp)
+        out = np.zeros_like(x)
+        axpy_jit(x, x, x, out)
+        self.assertPreciseEqual(out, x * x + x)
+
+    def test_output_scalar(self):
+
+        @guvectorize('(n),(m) -> ()')
+        def gufunc(x, y, res):
+            res[0] = x.sum() + y.sum()
+
+        @jit(nopython=True)
+        def jit_func(x, y, res):
+            gufunc(x, y, res)
+
+        x = np.arange(40, dtype='i8').reshape(4, 10)
+        y = np.arange(20, dtype='i8')
+        res = np.zeros(4, dtype='i8')
+        jit_func(x, y, res)
+        expected = np.zeros_like(res)
+        gufunc(x, y, expected)
+        self.assertPreciseEqual(res, expected)
+
+    def test_input_scalar(self):
+
+        @guvectorize('() -> ()')
+        def gufunc(x, res):
+            res[0] = x + 100
+
+        @jit(nopython=True)
+        def jit_func(x, res):
+            gufunc(x, res)
+
+        x = np.arange(40, dtype='i8').reshape(5, 2, 4)
+        res = np.zeros_like(x)
+        jit_func(x, res)
+        expected = np.zeros_like(res)
+        gufunc(x, expected)
+        self.assertPreciseEqual(res, expected)
+
+    def test_gufunc_ndim_mismatch(self):
+        signature = "(n, m), (n, n, n) -> (m), (n, n)"
+        @guvectorize(signature)
+        def bar(x, y, res, out):
+            res[0] = 123
+            out[0] = 456
+
+        @jit(nopython=True)
+        def foo(x, y, res, out):
+            bar(x, y, res, out)
+
+        N, M = 2, 3
+        x = np.arange(N**2).reshape(N, N)
+        y = np.arange(N**3).reshape(N, N, N)
+        res = np.arange(M)
+        out = np.arange(N**2).reshape(N, N)
+
+        # calling with a 1d array should result in an error
+        with self.assertRaises(TypingError) as raises:
+            x_ = np.arange(N * N)
+            foo(x_, y, res, out)
+        msg = ('bar: Input operand 0 does not have enough dimensions (has '
+               f'1, gufunc core with signature {signature} requires 2)')
+        self.assertIn(msg, str(raises.exception))
+
+        with self.assertRaises(TypingError) as raises:
+            y_ = np.arange(N * N).reshape(N, N)
+            foo(x, y_, res, out)
+        msg = ('bar: Input operand 1 does not have enough dimensions (has '
+               f'2, gufunc core with signature {signature} requires 3)')
+        self.assertIn(msg, str(raises.exception))
+
+        with self.assertRaises(TypingError) as raises:
+            res_ = np.array(3)
+            foo(x, y, res_, out)
+        msg = ('bar: Output operand 0 does not have enough dimensions (has '
+               f'0, gufunc core with signature {signature} requires 1)')
+        self.assertIn(msg, str(raises.exception))
+
+        with self.assertRaises(TypingError) as raises:
+            out_ = np.arange(N)
+            foo(x, y, res, out_)
+        msg = ('bar: Output operand 1 does not have enough dimensions (has '
+               f'1, gufunc core with signature {signature} requires 2)')
+        self.assertIn(msg, str(raises.exception))
+
+    def test_mismatch_inner_dimensions(self):
+        @guvectorize('(n),(n) -> ()')
+        def bar(x, y, res):
+            res[0] = 123
+
+        @jit(nopython=True)
+        def foo(x, y, res):
+            bar(x, y, res)
+
+        N = 2
+        M = 3
+        x = np.empty((5, 3, N))
+        y = np.empty((M,))
+        res = np.zeros((5, 3))
+
+        # ensure that NumPy raises an exception
+        with self.assertRaises(ValueError) as np_raises:
+            bar(x, y, res)
+        msg = ('Input operand 1 has a mismatch in its core dimension 0, with '
+               'gufunc signature (n),(n) -> () (size 3 is different from 2)')
+        self.assertIn(msg, str(np_raises.exception))
+
+        with self.assertRaises(ValueError) as raises:
+            foo(x, y, res)
+        msg = ('Operand has a mismatch in one of its core dimensions')
+        self.assertIn(msg, str(raises.exception))
+
+    def test_mismatch_inner_dimensions_input_output(self):
+        @guvectorize('(n),(m) -> (n)')
+        def bar(x, y, res):
+            res[0] = 123
+
+        @jit(nopython=True)
+        def foo(x, y, res):
+            bar(x, y, res)
+
+        N = 2
+        M = 3
+        x = np.empty((5, 3, N))
+        y = np.empty((M,))
+        res = np.zeros((5, 3))
+
+        # ensure that NumPy raises an exception
+        with self.assertRaises(ValueError) as np_raises:
+            bar(x, y, res)
+        msg = ('Output operand 0 has a mismatch in its core dimension 0, with '
+               'gufunc signature (n),(m) -> (n) (size 3 is different from 2)')
+        self.assertIn(msg, str(np_raises.exception))
+
+        with self.assertRaises(ValueError) as raises:
+            foo(x, y, res)
+        msg = ('Operand has a mismatch in one of its core dimensions')
+        self.assertIn(msg, str(raises.exception))
+
+    def test_mismatch_inner_dimensions_output(self):
+        @guvectorize('(n),(m) -> (m),(m)')
+        def bar(x, y, res, out):
+            res[0] = 123
+            out[0] = 456
+
+        @jit(nopython=True)
+        def foo(x, y, res, out):
+            bar(x, y, res, out)
+
+        N = 2
+        M = 3
+        x = np.empty((N,))
+        y = np.empty((M,))
+        res = np.zeros((N,))
+        out = np.zeros((M,))
+
+        # ensure that NumPy raises an exception
+        with self.assertRaises(ValueError) as np_raises:
+            bar(x, y, res, out)
+        msg = ('Output operand 0 has a mismatch in its core dimension 0, with '
+               'gufunc signature (n),(m) -> (m),(m) (size 2 is different from 3)')
+        self.assertIn(msg, str(np_raises.exception))
+
+        with self.assertRaises(ValueError) as raises:
+            foo(x, y, res, out)
+        msg = ('Operand has a mismatch in one of its core dimensions')
+        self.assertIn(msg, str(raises.exception))
+
+    def test_mismatch_loop_shape(self):
+        @guvectorize('(n),(n) -> ()')
+        def bar(x, y, res):
+            res[0] = 123
+
+        @jit(nopython=True)
+        def foo(x, y, res):
+            bar(x, y, res)
+
+        N = 2
+        x = np.empty((1, 5, 3, N,))
+        y = np.empty((5, 3, N,))
+        res = np.zeros((5, 3))
+
+        with self.assertRaises(ValueError) as raises:
+            foo(x, y, res)
+        msg = ('Loop and array shapes are incompatible')
+        self.assertIn(msg, str(raises.exception))
+
+    def test_mismatch_loop_shape_2(self):
+        @guvectorize('(n),(n) -> (), (n)')
+        def gufunc(x, y, res, out):
+            res[0] = x.sum()
+            for i in range(x.shape[0]):
+                out[i] += x[i] + y.sum()
+
+        @jit
+        def jit_func(x, y, res, out):
+            gufunc(x, y, res, out)
+
+        N = 2
+
+        x = np.arange(4*N).reshape((4, N))
+        y = np.arange(N)
+        res = np.empty((3,))
+        out = np.zeros((3, N))
+
+        # ensure that NumPy raises an exception
+        with self.assertRaises(ValueError) as np_raises:
+            gufunc(x, y, res, out)
+        msg = ('operands could not be broadcast together with remapped shapes '
+               '[original->remapped]: (4,2)->(4,newaxis) (2,)->() '
+               '(3,)->(3,newaxis) (3,2)->(3,2)  and requested shape (2)')
+        self.assertIn(msg, str(np_raises.exception))
+
+        with self.assertRaises(ValueError) as raises:
+            jit_func(x, y, res, out)
+        msg = ('Loop and array shapes are incompatible')
+        self.assertIn(msg, str(raises.exception))
+
+    def test_issue_10287(self):
+        @guvectorize([(float64[:], int64, float64[:])], "(n),()->(n)")
+        def guve(x, n, res):
+            pass
+
+
+        @jit
+        def njit_guve(x, n):
+            res = np.zeros_like(x)
+            guve(x, n, res)
+            return res
+
+
+        rng = np.random.default_rng(69)
+
+        for _ in range(20000):
+            x = rng.random(65)
+            y = np.repeat(x[None], 130, axis=0)
+            njit_guve(y, 5)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/test_parallel_env_variable.py

@@ -0,0 +1,38 @@
+from numba.np.ufunc.parallel import get_thread_count
+from os import environ as env
+from numba.core import config
+import unittest
+
+
+class TestParallelEnvVariable(unittest.TestCase):
+    """
+    Tests environment variables related to the underlying "parallel"
+    functions for npyufuncs.
+    """
+
+    _numba_parallel_test_ = False
+
+    def test_num_threads_variable(self):
+        """
+        Tests the NUMBA_NUM_THREADS env variable behaves as expected.
+        """
+        key = 'NUMBA_NUM_THREADS'
+        current = str(getattr(env, key, config.NUMBA_NUM_THREADS))
+        threads = "3154"
+        env[key] = threads
+        try:
+            config.reload_config()
+        except RuntimeError as e:
+            # This test should fail if threads have already been launched
+            self.assertIn("Cannot set NUMBA_NUM_THREADS", e.args[0])
+        else:
+            self.assertEqual(threads, str(get_thread_count()))
+            self.assertEqual(threads, str(config.NUMBA_NUM_THREADS))
+        finally:
+            # reset the env variable/set to default. Should not fail even if
+            # threads are launched because the value is the same.
+            env[key] = current
+            config.reload_config()
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/test_parallel_low_work.py

@@ -0,0 +1,44 @@
+"""
+There was a deadlock problem when work count is smaller than number of threads.
+"""
+
+import numpy as np
+
+from numba import float32, float64, int32, uint32
+from numba.np.ufunc import Vectorize
+import unittest
+
+
+def vector_add(a, b):
+    return a + b
+
+
+class TestParallelLowWorkCount(unittest.TestCase):
+
+    _numba_parallel_test_ = False
+
+    def test_low_workcount(self):
+        # build parallel native code ufunc
+        pv = Vectorize(vector_add, target='parallel')
+        for ty in (int32, uint32, float32, float64):
+            pv.add(ty(ty, ty))
+        para_ufunc = pv.build_ufunc()
+
+        # build python ufunc
+        np_ufunc = np.vectorize(vector_add)
+
+        # test it out
+        def test(ty):
+            data = np.arange(1).astype(ty) # just one item
+            result = para_ufunc(data, data)
+            gold = np_ufunc(data, data)
+            np.testing.assert_allclose(gold, result)
+
+        test(np.double)
+        test(np.float32)
+        test(np.int32)
+        test(np.uint32)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/test_parallel_ufunc_issues.py

@@ -0,0 +1,130 @@
+import time
+import ctypes
+
+import numpy as np
+
+from numba.tests.support import captured_stdout, skip_if_freethreading
+from numba import vectorize, guvectorize
+import unittest
+
+
+class TestParUfuncIssues(unittest.TestCase):
+
+    _numba_parallel_test_ = False
+
+    def test_thread_response(self):
+        """
+        Related to #89.
+        This does not test #89 but tests the fix for it.
+        We want to make sure the worker threads can be used multiple times
+        and with different time gap between each execution.
+        """
+
+        @vectorize('float64(float64, float64)', target='parallel')
+        def fnv(a, b):
+            return a + b
+
+        sleep_time = 1   # 1 second
+        while sleep_time > 0.00001:    # 10us
+            time.sleep(sleep_time)
+            a = b = np.arange(10**5)
+            np.testing.assert_equal(a + b, fnv(a, b))
+            # Reduce sleep time
+            sleep_time /= 2
+
+    @skip_if_freethreading
+    def test_gil_reacquire_deadlock(self):
+        """
+        Testing issue #1998 due to GIL reacquiring
+        """
+        # make a ctypes callback that requires the GIL
+        proto = ctypes.CFUNCTYPE(None, ctypes.c_int32)
+        characters = 'abcdefghij'
+
+        def bar(x):
+            print(characters[x])
+
+        cbar = proto(bar)
+
+        # our unit under test
+        @vectorize(['int32(int32)'], target='parallel', nopython=True)
+        def foo(x):
+            print(x % 10)  # this reacquires the GIL
+            cbar(x % 10)   # this reacquires the GIL
+            return x * 2
+
+        # Numpy ufunc has a heuristic to determine whether to release the GIL
+        # during execution.  Small input size (10) seems to not release the GIL.
+        # Large input size (1000) seems to release the GIL.
+        for nelem in [1, 10, 100, 1000]:
+            # inputs
+            a = np.arange(nelem, dtype=np.int32)
+            acopy = a.copy()
+            # run and capture stdout
+            with captured_stdout() as buf:
+                got = foo(a)
+            stdout = buf.getvalue()
+            buf.close()
+            # process outputs from print
+            got_output = sorted(map(lambda x: x.strip(), stdout.splitlines()))
+            # build expected output
+            expected_output = [str(x % 10) for x in range(nelem)]
+            expected_output += [characters[x % 10] for x in range(nelem)]
+            expected_output = sorted(expected_output)
+            # verify
+            self.assertEqual(got_output, expected_output)
+            np.testing.assert_equal(got, 2 * acopy)
+
+
+
+class TestParGUfuncIssues(unittest.TestCase):
+
+    _numba_parallel_test_ = False
+
+    @skip_if_freethreading
+    def test_gil_reacquire_deadlock(self):
+        """
+        Testing similar issue to #1998 due to GIL reacquiring for Gufunc
+        """
+        # make a ctypes callback that requires the GIL
+        proto = ctypes.CFUNCTYPE(None, ctypes.c_int32)
+        characters = 'abcdefghij'
+
+        def bar(x):
+            print(characters[x])
+
+        cbar = proto(bar)
+
+        # our unit under test
+        @guvectorize(['(int32, int32[:])'], "()->()",
+                     target='parallel', nopython=True)
+        def foo(x, out):
+            print(x % 10)  # this reacquires the GIL
+            cbar(x % 10)   # this reacquires the GIL
+            out[0] = x * 2
+
+        # Numpy ufunc has a heuristic to determine whether to release the GIL
+        # during execution.  Small input size (10) seems to not release the GIL.
+        # Large input size (1000) seems to release the GIL.
+        for nelem in [1, 10, 100, 1000]:
+            # inputs
+            a = np.arange(nelem, dtype=np.int32)
+            acopy = a.copy()
+            # run and capture stdout
+            with captured_stdout() as buf:
+                got = foo(a)
+            stdout = buf.getvalue()
+            buf.close()
+            # process outputs from print
+            got_output = sorted(map(lambda x: x.strip(), stdout.splitlines()))
+            # build expected output
+            expected_output = [str(x % 10) for x in range(nelem)]
+            expected_output += [characters[x % 10] for x in range(nelem)]
+            expected_output = sorted(expected_output)
+            # verify
+            self.assertEqual(got_output, expected_output)
+            np.testing.assert_equal(got, 2 * acopy)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/test_ufunc.py

@@ -0,0 +1,173 @@
+import numpy as np
+
+from numba import float32, jit, njit
+from numba.np.ufunc import Vectorize
+from numba.core.errors import TypingError
+from numba.tests.support import TestCase
+import unittest
+
+
+dtype = np.float32
+a = np.arange(80, dtype=dtype).reshape(8, 10)
+b = a.copy()
+c = a.copy(order='F')
+d = np.arange(16 * 20, dtype=dtype).reshape(16, 20)[::2, ::2]
+
+
+def add(a, b):
+    return a + b
+
+
+def add_multiple_args(a, b, c, d):
+    return a + b + c + d
+
+
+def gufunc_add(a, b):
+    result = 0.0
+    for i in range(a.shape[0]):
+        result += a[i] * b[i]
+
+    return result
+
+
+def ufunc_reduce(ufunc, arg):
+    for i in range(arg.ndim):
+        arg = ufunc.reduce(arg)
+    return arg
+
+
+vectorizers = [
+    Vectorize,
+    # ParallelVectorize,
+    # StreamVectorize,
+    # CudaVectorize,
+    # GUFuncVectorize,
+]
+
+
+class TestUFuncs(TestCase):
+
+    def _test_ufunc_attributes(self, cls, a, b, *args):
+        "Test ufunc attributes"
+        vectorizer = cls(add, *args)
+        vectorizer.add(float32(float32, float32))
+        ufunc = vectorizer.build_ufunc()
+
+        info = (cls, a.ndim)
+        self.assertPreciseEqual(ufunc(a, b), a + b, msg=info)
+        self.assertPreciseEqual(ufunc_reduce(ufunc, a), np.sum(a), msg=info)
+        self.assertPreciseEqual(ufunc.accumulate(a), np.add.accumulate(a),
+                                msg=info)
+        self.assertPreciseEqual(ufunc.outer(a, b), np.add.outer(a, b), msg=info)
+
+    def _test_broadcasting(self, cls, a, b, c, d):
+        "Test multiple args"
+        vectorizer = cls(add_multiple_args)
+        vectorizer.add(float32(float32, float32, float32, float32))
+        ufunc = vectorizer.build_ufunc()
+
+        info = (cls, a.shape)
+        self.assertPreciseEqual(ufunc(a, b, c, d), a + b + c + d, msg=info)
+
+    def test_ufunc_attributes(self):
+        for v in vectorizers: # 1D
+            self._test_ufunc_attributes(v, a[0], b[0])
+        for v in vectorizers: # 2D
+            self._test_ufunc_attributes(v, a, b)
+        for v in vectorizers: # 3D
+            self._test_ufunc_attributes(v, a[:, np.newaxis, :],
+                                        b[np.newaxis, :, :])
+
+    def test_broadcasting(self):
+        for v in vectorizers: # 1D
+            self._test_broadcasting(v, a[0], b[0], c[0], d[0])
+        for v in vectorizers: # 2D
+            self._test_broadcasting(v, a, b, c, d)
+        for v in vectorizers: # 3D
+            self._test_broadcasting(v, a[:, np.newaxis, :], b[np.newaxis, :, :],
+                                    c[:, np.newaxis, :], d[np.newaxis, :, :])
+
+    def test_implicit_broadcasting(self):
+        for v in vectorizers:
+            vectorizer = v(add)
+            vectorizer.add(float32(float32, float32))
+            ufunc = vectorizer.build_ufunc()
+
+            broadcasting_b = b[np.newaxis, :, np.newaxis, np.newaxis, :]
+            self.assertPreciseEqual(ufunc(a, broadcasting_b),
+                                    a + broadcasting_b)
+
+    def test_ufunc_exception_on_write_to_readonly(self):
+        z = np.ones(10)
+        z.flags.writeable = False # flip write bit
+
+        tests = []
+        expect = "ufunc 'sin' called with an explicit output that is read-only"
+        tests.append((jit(nopython=True), TypingError, expect))
+        tests.append((jit(forceobj=True), ValueError,
+                      "output array is read-only"))
+
+        for dec, exc, msg in tests:
+            def test(x):
+                a = np.ones(x.shape, x.dtype) # do not copy RO attribute from x
+                np.sin(a, x)
+
+            with self.assertRaises(exc) as raises:
+                dec(test)(z)
+
+            self.assertIn(msg, str(raises.exception))
+
+    def test_optional_type_handling(self):
+        # Tests ufunc compilation with Optional type
+
+        @njit
+        def inner(x, y):
+            if y > 2:
+                z = None
+            else:
+                z = np.ones(4)
+            return np.add(x, z)
+
+        # This causes `z` to be np.ones(4) at runtime, success
+        self.assertPreciseEqual(inner(np.arange(4), 1),
+                                np.arange(1, 5).astype(np.float64))
+
+        with self.assertRaises(TypeError) as raises:
+            # This causes `z` to be None at runtime, TypeError raised on the
+            # type cast of the Optional.
+            inner(np.arange(4), 3)
+
+        msg = "expected array(float64, 1d, C), got None"
+        self.assertIn(msg, str(raises.exception))
+
+
+class TestUFuncsMisc(TestCase):
+    # Test for miscellaneous ufunc issues
+
+    def test_exp2(self):
+        # See issue #8898, and TargetLibraryInfo based fix in #9336
+        @njit
+        def foo(x):
+            return np.exp2(x)
+
+        for ty in (np.int8, np.uint16):
+            x = ty(2)
+            expected = foo.py_func(x)
+            got = foo(x)
+            self.assertPreciseEqual(expected, got)
+
+    def test_log2(self):
+        # See issue #8898, and TargetLibraryInfo based fix in #9336
+        @njit
+        def foo(x):
+            return np.log2(x)
+
+        for ty in (np.int8, np.uint16):
+            x = ty(2)
+            expected = foo.py_func(x)
+            got = foo(x)
+            self.assertPreciseEqual(expected, got)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/test_ufuncbuilding.py

@@ -0,0 +1,471 @@
+import pickle
+import unittest
+
+import numpy as np
+from numpy.testing import assert_array_equal
+
+from numba.np.ufunc.ufuncbuilder import GUFuncBuilder
+from numba import vectorize, guvectorize
+from numba.np.ufunc import PyUFunc_One
+from numba.np.ufunc.dufunc import DUFunc as UFuncBuilder
+from numba.tests.support import tag, TestCase
+from numba.core import config
+
+
+class TestUfuncBuilding(TestCase):
+
+    def test_basic_ufunc(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import add
+        ufb = UFuncBuilder(add)
+        cres = ufb.add("int32(int32, int32)")
+        self.assertFalse(cres.objectmode)
+        cres = ufb.add("int64(int64, int64)")
+        self.assertFalse(cres.objectmode)
+        ufunc = ufb.build_ufunc()
+
+        def check(a):
+            b = ufunc(a, a)
+            self.assertPreciseEqual(a + a, b)
+            self.assertEqual(b.dtype, a.dtype)
+
+        a = np.arange(12, dtype='int32')
+        check(a)
+        # Non-contiguous dimension
+        a = a[::2]
+        check(a)
+        a = a.reshape((2, 3))
+        check(a)
+
+        # Metadata
+        self.assertEqual(ufunc.__name__, "add")
+        self.assertIn("An addition", ufunc.__doc__)
+
+    def test_ufunc_struct(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import add
+        ufb = UFuncBuilder(add)
+        cres = ufb.add("complex64(complex64, complex64)")
+        self.assertFalse(cres.objectmode)
+        ufunc = ufb.build_ufunc()
+
+        def check(a):
+            b = ufunc(a, a)
+            self.assertPreciseEqual(a + a, b)
+            self.assertEqual(b.dtype, a.dtype)
+
+        a = np.arange(12, dtype='complex64') + 1j
+        check(a)
+        # Non-contiguous dimension
+        a = a[::2]
+        check(a)
+        a = a.reshape((2, 3))
+        check(a)
+
+    def test_ufunc_forceobj(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import add
+        ufb = UFuncBuilder(add, targetoptions={'forceobj': True})
+        cres = ufb.add("int32(int32, int32)")
+        self.assertTrue(cres.objectmode)
+        ufunc = ufb.build_ufunc()
+
+        a = np.arange(10, dtype='int32')
+        b = ufunc(a, a)
+        self.assertPreciseEqual(a + a, b)
+
+    def test_nested_call(self):
+        """
+        Check nested call to an implicitly-typed ufunc.
+        """
+        from numba.tests.npyufunc.ufuncbuilding_usecases import outer
+        builder = UFuncBuilder(outer,
+                               targetoptions={'nopython': True})
+        builder.add("(int64, int64)")
+        ufunc = builder.build_ufunc()
+        self.assertEqual(ufunc(-1, 3), 2)
+
+    def test_nested_call_explicit(self):
+        """
+        Check nested call to an explicitly-typed ufunc.
+        """
+        from numba.tests.npyufunc.ufuncbuilding_usecases import outer_explicit
+        builder = UFuncBuilder(outer_explicit,
+                               targetoptions={'nopython': True})
+        builder.add("(int64, int64)")
+        ufunc = builder.build_ufunc()
+        self.assertEqual(ufunc(-1, 3), 2)
+
+
+class TestUfuncBuildingJitDisabled(TestUfuncBuilding):
+
+    def setUp(self):
+        self.old_disable_jit = config.DISABLE_JIT
+        config.DISABLE_JIT = False
+
+    def tearDown(self):
+        config.DISABLE_JIT = self.old_disable_jit
+
+
+class TestGUfuncBuilding(TestCase):
+
+    def test_basic_gufunc(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import guadd
+        gufb = GUFuncBuilder(guadd, "(x, y),(x, y)->(x, y)")
+        cres = gufb.add("void(int32[:,:], int32[:,:], int32[:,:])")
+        self.assertFalse(cres.objectmode)
+        ufunc = gufb.build_ufunc()
+
+        a = np.arange(10, dtype="int32").reshape(2, 5)
+        b = ufunc(a, a)
+
+        self.assertPreciseEqual(a + a, b)
+        self.assertEqual(b.dtype, np.dtype('int32'))
+
+        # Metadata
+        self.assertEqual(ufunc.__name__, "guadd")
+        self.assertIn("A generalized addition", ufunc.__doc__)
+
+    def test_gufunc_struct(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import guadd
+        gufb = GUFuncBuilder(guadd, "(x, y),(x, y)->(x, y)")
+        cres = gufb.add("void(complex64[:,:], complex64[:,:], complex64[:,:])")
+        self.assertFalse(cres.objectmode)
+        ufunc = gufb.build_ufunc()
+
+        a = np.arange(10, dtype="complex64").reshape(2, 5) + 1j
+        b = ufunc(a, a)
+
+        self.assertPreciseEqual(a + a, b)
+
+    def test_gufunc_struct_forceobj(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import guadd
+        gufb = GUFuncBuilder(guadd, "(x, y),(x, y)->(x, y)",
+                             targetoptions=dict(forceobj=True))
+        cres = gufb.add("void(complex64[:,:], complex64[:,:], complex64[:,"
+                        ":])")
+        self.assertTrue(cres.objectmode)
+        ufunc = gufb.build_ufunc()
+
+        a = np.arange(10, dtype="complex64").reshape(2, 5) + 1j
+        b = ufunc(a, a)
+
+        self.assertPreciseEqual(a + a, b)
+
+
+class TestGUfuncBuildingJitDisabled(TestGUfuncBuilding):
+
+    def setUp(self):
+        self.old_disable_jit = config.DISABLE_JIT
+        config.DISABLE_JIT = False
+
+    def tearDown(self):
+        config.DISABLE_JIT = self.old_disable_jit
+
+
+class TestVectorizeDecor(TestCase):
+
+    _supported_identities = [0, 1, None, "reorderable"]
+
+    def test_vectorize(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import add
+        ufunc = vectorize(['int32(int32, int32)'])(add)
+        a = np.arange(10, dtype='int32')
+        b = ufunc(a, a)
+        self.assertPreciseEqual(a + a, b)
+
+    def test_vectorize_objmode(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import add
+        ufunc = vectorize(['int32(int32, int32)'], forceobj=True)(add)
+        a = np.arange(10, dtype='int32')
+        b = ufunc(a, a)
+        self.assertPreciseEqual(a + a, b)
+
+    def test_vectorize_bool_return(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import equals
+        ufunc = vectorize(['bool_(int32, int32)'])(equals)
+        a = np.arange(10, dtype='int32')
+        r = ufunc(a,a)
+        self.assertPreciseEqual(r, np.ones(r.shape, dtype=np.bool_))
+
+    def test_vectorize_identity(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import add
+        sig = 'int32(int32, int32)'
+        for identity in self._supported_identities:
+            ufunc = vectorize([sig], identity=identity)(add)
+            expected = None if identity == 'reorderable' else identity
+            self.assertEqual(ufunc.identity, expected)
+        # Default value is None
+        ufunc = vectorize([sig])(add)
+        self.assertIs(ufunc.identity, None)
+        # Invalid values
+        with self.assertRaises(ValueError):
+            vectorize([sig], identity='none')(add)
+        with self.assertRaises(ValueError):
+            vectorize([sig], identity=2)(add)
+
+    def test_vectorize_no_args(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import add
+        a = np.linspace(0,1,10)
+        b = np.linspace(1,2,10)
+        ufunc = vectorize(add)
+        self.assertPreciseEqual(ufunc(a,b), a + b)
+        ufunc2 = vectorize(add)
+        c = np.empty(10)
+        ufunc2(a, b, c)
+        self.assertPreciseEqual(c, a + b)
+
+    def test_vectorize_only_kws(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import mul
+        a = np.linspace(0,1,10)
+        b = np.linspace(1,2,10)
+        ufunc = vectorize(identity=PyUFunc_One, nopython=True)(mul)
+        self.assertPreciseEqual(ufunc(a,b), a * b)
+
+    def test_vectorize_output_kwarg(self):
+        """
+        Passing the output array as a keyword argument (issue #1867).
+        """
+        def check(ufunc):
+            a = np.arange(10, 16, dtype='int32')
+            out = np.zeros_like(a)
+            got = ufunc(a, a, out=out)
+            self.assertIs(got, out)
+            self.assertPreciseEqual(out, a + a)
+            with self.assertRaises(TypeError):
+                ufunc(a, a, zzz=out)
+
+        # With explicit sigs
+        from numba.tests.npyufunc.ufuncbuilding_usecases import add
+        ufunc = vectorize(['int32(int32, int32)'], nopython=True)(add)
+        check(ufunc)
+        # With implicit sig
+        ufunc = vectorize(nopython=True)(add)
+        check(ufunc)  # compiling
+        check(ufunc)  # after compiling
+
+    def test_guvectorize(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import guadd
+        ufunc = guvectorize(['(int32[:,:], int32[:,:], int32[:,:])'],
+                            "(x,y),(x,y)->(x,y)")(guadd)
+        a = np.arange(10, dtype='int32').reshape(2, 5)
+        b = ufunc(a, a)
+        self.assertPreciseEqual(a + a, b)
+
+    def test_guvectorize_no_output(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import guadd
+        ufunc = guvectorize(['(int32[:,:], int32[:,:], int32[:,:])'],
+                            "(x,y),(x,y),(x,y)")(guadd)
+        a = np.arange(10, dtype='int32').reshape(2, 5)
+        out = np.zeros_like(a)
+        ufunc(a, a, out)
+        self.assertPreciseEqual(a + a, out)
+
+    def test_guvectorize_objectmode(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import guadd_obj
+        ufunc = guvectorize(['(int32[:,:], int32[:,:], int32[:,:])'],
+                            "(x,y),(x,y)->(x,y)", forceobj=True)(guadd_obj)
+        a = np.arange(10, dtype='int32').reshape(2, 5)
+        b = ufunc(a, a)
+        self.assertPreciseEqual(a + a, b)
+
+    def test_guvectorize_scalar_objectmode(self):
+        """
+        Test passing of scalars to object mode gufuncs.
+        """
+        from numba.tests.npyufunc.ufuncbuilding_usecases import guadd_scalar_obj
+        ufunc = guvectorize(['(int32[:,:], int32, int32[:,:])'],
+                            "(x,y),()->(x,y)", forceobj=True)(guadd_scalar_obj)
+        a = np.arange(10, dtype='int32').reshape(2, 5)
+        b = ufunc(a, 3)
+        self.assertPreciseEqual(a + 3, b)
+
+    def test_guvectorize_error_in_objectmode(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import guerror, \
+            MyException
+        ufunc = guvectorize(['(int32[:,:], int32[:,:], int32[:,:])'],
+                            "(x,y),(x,y)->(x,y)", forceobj=True)(guerror)
+        a = np.arange(10, dtype='int32').reshape(2, 5)
+        with self.assertRaises(MyException):
+            ufunc(a, a)
+
+    def test_guvectorize_identity(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import add, guadd
+        args = (['(int32[:,:], int32[:,:], int32[:,:])'], "(x,y),(x,y)->(x,y)")
+        for identity in self._supported_identities:
+            ufunc = guvectorize(*args, identity=identity)(guadd)
+            expected = None if identity == 'reorderable' else identity
+            self.assertEqual(ufunc.identity, expected)
+        # Default value is None
+        ufunc = guvectorize(*args)(guadd)
+        self.assertIs(ufunc.identity, None)
+        # Invalid values
+        with self.assertRaises(ValueError):
+            guvectorize(*args, identity='none')(add)
+        with self.assertRaises(ValueError):
+            guvectorize(*args, identity=2)(add)
+
+    def test_guvectorize_invalid_layout(self):
+        from numba.tests.npyufunc.ufuncbuilding_usecases import guadd
+        sigs = ['(int32[:,:], int32[:,:], int32[:,:])']
+        # Syntax error
+        with self.assertRaises(ValueError) as raises:
+            guvectorize(sigs, ")-:")(guadd)
+        self.assertIn("bad token in signature", str(raises.exception))
+        # Output shape can't be inferred from inputs
+        with self.assertRaises(NameError) as raises:
+            guvectorize(sigs, "(x,y),(x,y)->(x,z,v)")(guadd)
+        self.assertEqual(str(raises.exception),
+                         "undefined output symbols: v,z")
+        # Arrow but no outputs
+        with self.assertRaises(ValueError) as raises:
+            guvectorize(sigs, "(x,y),(x,y),(x,y)->")(guadd)
+        # (error message depends on Numpy version)
+
+
+class NEP13Array:
+    """https://numpy.org/neps/nep-0013-ufunc-overrides.html"""
+    def __init__(self, array):
+        self.array = array
+
+    def __array__(self):
+        return self.array
+
+    def tolist(self):
+        return self.array.tolist()
+
+    def __array_ufunc__(self, ufunc, method, *args, **kwargs):
+        if method != "__call__":
+            return NotImplemented
+
+        return NEP13Array(ufunc(*[np.asarray(x) for x in args], **kwargs))
+
+
+class FakeDaskArray:
+    """This class defines both the NEP13 protocol and the dask collection protocol
+    (https://docs.dask.org/en/stable/custom-collections.html). This is a stand-in for
+    dask array, dask dataframe, and for any wrapper around them (e.g. xarray or pint).
+    """
+
+    def __init__(self, array):
+        self.array = array
+
+    def __array_ufunc__(self, ufunc, method, *args, **kwargs):
+        if method != "__call__":
+            return NotImplemented
+
+        # Simulate sending the ufunc over the network and applying it on a remote worker
+        ufunc = pickle.loads(pickle.dumps(ufunc))
+        args = [x.array if isinstance(x, FakeDaskArray) else x for x in args]
+        return FakeDaskArray(ufunc(*args, **kwargs))
+
+    def _dask_method(self, *args, **kwargs):
+        raise AssertionError("called potentially expensive method")
+
+    __array__ = _dask_method
+    __dask_graph__ = _dask_method
+    __dask_keys__ = _dask_method
+    __dask_optimize__ = _dask_method
+    __dask_postcompute__ = _dask_method
+    __dask_postpersist__ = _dask_method
+    __dask_scheduler__ = _dask_method
+    __dask_tokenize__ = _dask_method
+    compute = _dask_method
+    persist = _dask_method
+    visualize = _dask_method
+
+
+class TestNEP13WithoutSignature(TestCase):
+
+    def test_all(self):
+
+        # note: no signatures specified
+        @vectorize(nopython=True)
+        def new_ufunc(hundreds, tens, ones):
+            return 100*hundreds + 10*tens + ones
+
+        # give it integers
+        a = np.array([1, 2, 3], dtype=np.int64)
+        b = np.array([4, 5, 6], dtype=np.int64)
+        c = np.array([7, 8, 9], dtype=np.int64)
+
+        all_np = new_ufunc(a, b, c)
+        self.assertIsInstance(all_np, np.ndarray)
+        self.assertEqual(all_np.tolist(), [147, 258, 369])
+
+        nep13_1 = new_ufunc(NEP13Array(a), b, c)
+        self.assertIsInstance(nep13_1, NEP13Array)
+        self.assertEqual(nep13_1.tolist(), [147, 258, 369])
+
+        nep13_2 = new_ufunc(a, NEP13Array(b), c)
+        self.assertIsInstance(nep13_2, NEP13Array)
+        self.assertEqual(nep13_2.tolist(), [147, 258, 369])
+
+        nep13_3 = new_ufunc(a, b, NEP13Array(c))
+        self.assertIsInstance(nep13_3, NEP13Array)
+        self.assertEqual(nep13_3.tolist(), [147, 258, 369])
+
+        # give it floats
+        a = np.array([1.1, 2.2, 3.3], dtype=np.float64)
+        b = np.array([4.4, 5.5, 6.6], dtype=np.float64)
+        c = np.array([7.7, 8.8, 9.9], dtype=np.float64)
+
+        all_np = new_ufunc(a, b, c)
+        self.assertIsInstance(all_np, np.ndarray)
+        self.assertEqual(all_np.tolist(), [161.7, 283.8, 405.9])
+
+        nep13_1 = new_ufunc(NEP13Array(a), b, c)
+        self.assertIsInstance(nep13_1, NEP13Array)
+        self.assertEqual(nep13_1.tolist(), [161.7, 283.8, 405.9])
+
+        nep13_2 = new_ufunc(a, NEP13Array(b), c)
+        self.assertIsInstance(nep13_2, NEP13Array)
+        self.assertEqual(nep13_2.tolist(), [161.7, 283.8, 405.9])
+
+        nep13_3 = new_ufunc(a, b, NEP13Array(c))
+        self.assertIsInstance(nep13_3, NEP13Array)
+        self.assertEqual(nep13_3.tolist(), [161.7, 283.8, 405.9])
+
+
+class TestDask(unittest.TestCase):
+    """Test that numba ufuncs are compatible with dask collections and wrappers around
+    dask (e.g. xarray or pint) and that they can be serialized, sent over the network,
+    deserialized on a different host and applied remotely.
+    """
+
+    def test_dask_array(self):
+        a = FakeDaskArray(np.arange(4, dtype=np.float64))
+        expect = np.arange(4, dtype=np.float64) * 2
+
+        @vectorize(["f8(f8)"])
+        def double_static_vectorize(x):
+            return x * 2
+
+        @vectorize()
+        def double_dynamic_vectorize(x):
+            return x * 2
+
+        @guvectorize(["f8,f8[:]"], "()->()")
+        def double_guvectorize(x, out):
+            out[:] = x * 2
+
+        for func in (
+            double_static_vectorize,
+            double_dynamic_vectorize,
+            double_guvectorize,
+        ):
+            with self.subTest(func):
+                b = func(a)
+                assert isinstance(b, FakeDaskArray)
+                assert_array_equal(b.array, expect)
+
+
+class TestVectorizeDecorJitDisabled(TestVectorizeDecor):
+
+    def setUp(self):
+        self.old_disable_jit = config.DISABLE_JIT
+        config.DISABLE_JIT = False
+
+    def tearDown(self):
+        config.DISABLE_JIT = self.old_disable_jit
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/test_update_inplace.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+from __future__ import print_function, absolute_import, division
+
+import unittest
+
+import numpy as np
+from numba import guvectorize
+from numba.tests.support import TestCase
+
+
+def py_replace_2nd(x_t, y_1):
+    for t in range(0, x_t.shape[0], 2):
+        x_t[t] = y_1[0]
+
+
+def py_update_3(x0_t, x1_t, x2_t, y_1):
+    for t in range(0, x0_t.shape[0]):
+        x0_t[t] = y_1[0]
+        x1_t[t] = 2 * y_1[0]
+        x2_t[t] = 3 * y_1[0]
+
+
+class TestUpdateInplace(TestCase):
+
+    def _run_test_for_gufunc(self, gufunc, py_func, expect_f4_to_pass=True,
+                             z=2):
+        for dtype, expect_to_pass in [('f8', True), ('f4', expect_f4_to_pass)]:
+            inputs = [np.zeros(10, dtype) for _ in range(gufunc.nin - 1)]
+            ex_inputs = [x_t.copy() for x_t in inputs]
+
+            gufunc(*inputs, z)
+            py_func(*ex_inputs, np.array([z]))
+
+            for i, (x_t, ex_x_t) in enumerate(zip(inputs, ex_inputs)):
+                if expect_to_pass:
+                    np.testing.assert_equal(x_t, ex_x_t, err_msg='input %s' % i)
+                else:
+                    self.assertFalse((x_t == ex_x_t).all(), msg='input %s' % i)
+
+    def test_update_inplace(self):
+        # test without writable_args
+        gufunc = guvectorize(['void(f8[:], f8[:])'], '(t),()',
+                             nopython=True)(py_replace_2nd)
+        self._run_test_for_gufunc(gufunc, py_replace_2nd,
+                                  expect_f4_to_pass=False)
+
+        # test with writable_args
+        gufunc = guvectorize(['void(f8[:], f8[:])'], '(t),()',
+                             nopython=True, writable_args=(0,))(py_replace_2nd)
+        self._run_test_for_gufunc(gufunc, py_replace_2nd)
+
+        # test with writable_args as strings
+        gufunc = guvectorize(['void(f8[:], f8[:])'], '(t),()', nopython=True,
+                             writable_args=('x_t',))(py_replace_2nd)
+        self._run_test_for_gufunc(gufunc, py_replace_2nd)
+
+    def test_update_inplace_with_cache(self):
+        # test with writable_args
+        gufunc = guvectorize(['void(f8[:], f8[:])'], '(t),()',
+                             nopython=True, writable_args=(0,),
+                             cache=True)(py_replace_2nd)
+        # 2nd time it is loaded from cache
+        gufunc = guvectorize(['void(f8[:], f8[:])'], '(t),()',
+                             nopython=True, writable_args=(0,),
+                             cache=True)(py_replace_2nd)
+        self._run_test_for_gufunc(gufunc, py_replace_2nd)
+
+    def test_update_inplace_parallel(self):
+        # test with writable_args
+        gufunc = guvectorize(['void(f8[:], f8[:])'], '(t),()',
+                             nopython=True, writable_args=(0,),
+                             target='parallel')(py_replace_2nd)
+        self._run_test_for_gufunc(gufunc, py_replace_2nd)
+
+    def test_update_inplace_3(self):
+        # test without writable_args
+        gufunc = guvectorize(['void(f8[:], f8[:], f8[:], f8[:])'],
+                             '(t),(t),(t),()',
+                             nopython=True)(py_update_3)
+        self._run_test_for_gufunc(gufunc, py_update_3, expect_f4_to_pass=False)
+
+        # test with writable_args
+        gufunc = guvectorize(['void(f8[:], f8[:], f8[:], f8[:])'],
+                             '(t),(t),(t),()', nopython=True,
+                             writable_args=(0, 1, 2))(py_update_3)
+        self._run_test_for_gufunc(gufunc, py_update_3)
+
+        # test with writable_args as mix of strings and ints
+        gufunc = guvectorize(['void(f8[:], f8[:], f8[:], f8[:])'],
+                             '(t),(t),(t),()', nopython=True,
+                             writable_args=('x0_t', 'x1_t', 2))(py_update_3)
+        self._run_test_for_gufunc(gufunc, py_update_3)
+
+    def test_exceptions(self):
+        # check that len(writable_args) <= nin
+        with self.assertRaises(ValueError):
+            guvectorize(['void(f8[:], f8[:])'], '(t),()', nopython=True,
+                        writable_args=(0, 1, 2, 5))(py_replace_2nd)
+
+        # check that all values in writable_args are between 0 and nin
+        with self.assertRaises(ValueError):
+            guvectorize(['void(f8[:], f8[:])'], '(t),()',
+                        nopython=True, writable_args=(5,))(py_replace_2nd)
+
+        with self.assertRaises(ValueError):
+            guvectorize(['void(f8[:], f8[:])'], '(t),()',
+                        nopython=True, writable_args=(-1,))(py_replace_2nd)
+
+        # check that exception is raised when passing non-existing argument name
+        with self.assertRaises(RuntimeError):
+            guvectorize(['void(f8[:], f8[:])'], '(t),()',
+                        nopython=True, writable_args=('z_t',))(py_replace_2nd)
+
+        # writable_args are not supported for target='cuda'
+        with self.assertRaises(TypeError):
+            guvectorize(['void(f8[:], f8[:])'], '(t),()',
+                        nopython=True, writable_args=(0,),
+                        target='cuda')(py_replace_2nd)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/test_vectorize_decor.py

@@ -0,0 +1,151 @@
+import math
+
+import numpy as np
+
+from numba import int32, uint32, float32, float64, jit, vectorize
+from numba.tests.support import tag, CheckWarningsMixin
+import unittest
+
+
+pi = math.pi
+
+
+def sinc(x):
+    if x == 0.0:
+        return 1.0
+    else:
+        return math.sin(x * pi) / (pi * x)
+
+def scaled_sinc(x, scale):
+    if x == 0.0:
+        return scale
+    else:
+        return scale * (math.sin(x * pi) / (pi * x))
+
+def vector_add(a, b):
+    return a + b
+
+
+class BaseVectorizeDecor(object):
+    target = None
+    wrapper = None
+    funcs = {
+        'func1': sinc,
+        'func2': scaled_sinc,
+        'func3': vector_add,
+    }
+
+    @classmethod
+    def _run_and_compare(cls, func, sig, A, *args, **kwargs):
+        if cls.wrapper is not None:
+            func = cls.wrapper(func)
+        numba_func = vectorize(sig, target=cls.target)(func)
+        numpy_func = np.vectorize(func)
+        result = numba_func(A, *args)
+        gold = numpy_func(A, *args)
+        np.testing.assert_allclose(result, gold, **kwargs)
+
+    def test_1(self):
+        sig = ['float64(float64)', 'float32(float32)']
+        func = self.funcs['func1']
+        A = np.arange(100, dtype=np.float64)
+        self._run_and_compare(func, sig, A)
+
+    def test_2(self):
+        sig = [float64(float64), float32(float32)]
+        func = self.funcs['func1']
+        A = np.arange(100, dtype=np.float64)
+        self._run_and_compare(func, sig, A)
+
+    def test_3(self):
+        sig = ['float64(float64, uint32)']
+        func = self.funcs['func2']
+        A = np.arange(100, dtype=np.float64)
+        scale = np.uint32(3)
+        self._run_and_compare(func, sig, A, scale, atol=1e-8)
+
+    def test_4(self):
+        sig = [
+            int32(int32, int32),
+            uint32(uint32, uint32),
+            float32(float32, float32),
+            float64(float64, float64),
+        ]
+        func = self.funcs['func3']
+        A = np.arange(100, dtype=np.float64)
+        self._run_and_compare(func, sig, A, A)
+        A = A.astype(np.float32)
+        self._run_and_compare(func, sig, A, A)
+        A = A.astype(np.int32)
+        self._run_and_compare(func, sig, A, A)
+        A = A.astype(np.uint32)
+        self._run_and_compare(func, sig, A, A)
+
+
+class TestCPUVectorizeDecor(unittest.TestCase, BaseVectorizeDecor):
+    target = 'cpu'
+
+
+class TestParallelVectorizeDecor(unittest.TestCase, BaseVectorizeDecor):
+    _numba_parallel_test_ = False
+    target = 'parallel'
+
+
+class TestCPUVectorizeJitted(unittest.TestCase, BaseVectorizeDecor):
+    target = 'cpu'
+    wrapper = jit(nopython=True)
+
+
+class BaseVectorizeNopythonArg(unittest.TestCase, CheckWarningsMixin):
+    """
+    Test passing the nopython argument to the vectorize decorator.
+    """
+    def _test_target_nopython(self, target, warnings, with_sig=True):
+        a = np.array([2.0], dtype=np.float32)
+        b = np.array([3.0], dtype=np.float32)
+        sig = [float32(float32, float32)]
+        args = with_sig and [sig] or []
+        with self.check_warnings(warnings):
+            f = vectorize(*args, target=target, nopython=True)(vector_add)
+            f(a, b)
+
+class TestVectorizeNopythonArg(BaseVectorizeNopythonArg):
+    def test_target_cpu_nopython(self):
+        self._test_target_nopython('cpu', [])
+
+    def test_target_cpu_nopython_no_sig(self):
+        self._test_target_nopython('cpu', [], False)
+
+    def test_target_parallel_nopython(self):
+        self._test_target_nopython('parallel', [])
+
+
+class BaseVectorizeUnrecognizedArg(unittest.TestCase, CheckWarningsMixin):
+    """
+    Test passing an unrecognized argument to the vectorize decorator.
+    """
+    def _test_target_unrecognized_arg(self, target, with_sig=True):
+        a = np.array([2.0], dtype=np.float32)
+        b = np.array([3.0], dtype=np.float32)
+        sig = [float32(float32, float32)]
+        args = with_sig and [sig] or []
+        with self.assertRaises(KeyError) as raises:
+            f = vectorize(*args, target=target, nonexistent=2)(vector_add)
+            f(a, b)
+        self.assertIn("Unrecognized options", str(raises.exception))
+
+class TestVectorizeUnrecognizedArg(BaseVectorizeUnrecognizedArg):
+    def test_target_cpu_unrecognized_arg(self):
+        self._test_target_unrecognized_arg('cpu')
+
+    def test_target_cpu_unrecognized_arg_no_sig(self):
+        self._test_target_unrecognized_arg('cpu', False)
+
+    def test_target_parallel_unrecognized_arg(self):
+        self._test_target_unrecognized_arg('parallel')
+
+
+
+
+if __name__ == '__main__':
+    unittest.main()

data/conda_envs/evalclaw/lib/python3.11/site-packages/numba/tests/npyufunc/ufuncbuilding_usecases.py

@@ -0,0 +1,69 @@
+from numba import vectorize
+
+
+def add(a, b):
+    """An addition"""
+    return a + b
+
+
+def equals(a, b):
+    return a == b
+
+
+def mul(a, b):
+    """A multiplication"""
+    return a * b
+
+
+def guadd(a, b, c):
+    """A generalized addition"""
+    x, y = c.shape
+    for i in range(x):
+        for j in range(y):
+            c[i, j] = a[i, j] + b[i, j]
+
+
+@vectorize(nopython=True)
+def inner(a, b):
+    return a + b
+
+
+@vectorize(["int64(int64, int64)"], nopython=True)
+def inner_explicit(a, b):
+    return a + b
+
+
+def outer(a, b):
+    return inner(a, b)
+
+
+def outer_explicit(a, b):
+    return inner_explicit(a, b)
+
+
+class Dummy:
+    pass
+
+
+def guadd_obj(a, b, c):
+    Dummy()  # to force object mode
+    x, y = c.shape
+    for i in range(x):
+        for j in range(y):
+            c[i, j] = a[i, j] + b[i, j]
+
+
+def guadd_scalar_obj(a, b, c):
+    Dummy()  # to force object mode
+    x, y = c.shape
+    for i in range(x):
+        for j in range(y):
+            c[i, j] = a[i, j] + b
+
+
+class MyException(Exception):
+    pass
+
+
+def guerror(a, b, c):
+    raise MyException