Upload folder using huggingface_hub (part 9)

.gitattributes

@@ -114,3 +114,17 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/numba/np/ufunc/omppool.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/numba/np/ufunc/tbbpool.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 .venv/lib/python3.11/site-packages/numba/np/ufunc/workqueue.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numcodecs/_shuffle.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numcodecs/blosc.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numcodecs/compat_ext.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numcodecs/fletcher32.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numcodecs/jenkins.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numcodecs/lz4.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numcodecs/vlen.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numcodecs/zstd.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numpy/_core/__pycache__/_add_newdocs.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numpy/_core/__pycache__/fromnumeric.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numpy/_core/_multiarray_tests.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numpy/_core/_multiarray_umath.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numpy/_core/_simd.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+.venv/lib/python3.11/site-packages/numpy/f2py/__pycache__/crackfortran.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text

.venv/lib/python3.11/site-packages/numba-0.66.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

.venv/lib/python3.11/site-packages/numba-0.66.0.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: numba
+Version: 0.66.0
+Summary: compiling Python code using LLVM
+Home-page: https://numba.pydata.org
+License: BSD
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.10
+License-File: LICENSE
+License-File: LICENSES.third-party
+Requires-Dist: llvmlite<0.49,>=0.48.0dev0
+Requires-Dist: numpy<2.5,>=1.22
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+*****
+Numba
+*****
+
+.. image:: https://img.shields.io/badge/discuss-on%20discourse-blue
+   :target: https://numba.discourse.group/
+   :alt: Discourse
+
+.. image:: https://zenodo.org/badge/doi/10.5281/zenodo.4343230.svg
+   :target: https://doi.org/10.5281/zenodo.4343230
+   :alt: Zenodo
+
+.. image:: https://img.shields.io/pypi/v/numba.svg
+   :target: https://pypi.python.org/pypi/numba/
+   :alt: PyPI
+
+.. image:: https://dev.azure.com/numba/numba/_apis/build/status/numba.numba?branchName=main
+    :target: https://dev.azure.com/numba/numba/_build/latest?definitionId=1?branchName=main
+    :alt: Azure Pipelines
+
+A Just-In-Time Compiler for Numerical Functions in Python
+#########################################################
+
+Numba is an open source, NumPy-aware optimizing compiler for Python sponsored
+by Anaconda, Inc.  It uses the LLVM compiler project to generate machine code
+from Python syntax.
+
+Numba can compile a large subset of numerically-focused Python, including many
+NumPy functions.  Additionally, Numba has support for automatic
+parallelization of loops, generation of GPU-accelerated code, and creation of
+ufuncs and C callbacks.
+
+For more information about Numba, see the Numba homepage:
+https://numba.pydata.org and the online documentation:
+https://numba.readthedocs.io/en/stable/index.html
+
+Installation
+============
+
+Please follow the instructions:
+
+https://numba.readthedocs.io/en/stable/user/installing.html
+
+Demo
+====
+
+Please have a look and the demo notebooks via the mybinder service:
+
+https://mybinder.org/v2/gh/numba/numba-examples/master?filepath=notebooks
+
+Contact
+=======
+
+Numba has a discourse forum for discussions:
+
+* https://numba.discourse.group
+

.venv/lib/python3.11/site-packages/numba-0.66.0.dist-info/RECORD

@@ -0,0 +1,814 @@
+../../../bin/numba,sha256=oSXddtzzcSW1Wd1-_HIyF2LKZovTFrinztGANaYgWIg,237
+numba-0.66.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+numba-0.66.0.dist-info/METADATA,sha256=lXx4AG6WM5JgemDUY7PkhK90Xdxr3vEvDbtxIDiy5pk,2733
+numba-0.66.0.dist-info/RECORD,,
+numba-0.66.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba-0.66.0.dist-info/WHEEL,sha256=LzEbpIS1rN6HUKgX_HYQou3zndu2RacYEOrIqPjDwB0,151
+numba-0.66.0.dist-info/licenses/LICENSE,sha256=OnDgohytAxRyRvY2PQe_dvriFscneXB_SuXbBrys8Gc,1286
+numba-0.66.0.dist-info/licenses/LICENSES.third-party,sha256=_cYMoh2Ce-s4Nf_Gt6mb2hSlz8s3nQyCwF48H_SkgvI,26322
+numba-0.66.0.dist-info/sboms/auditwheel.cdx.json,sha256=1vDV3a0Yg1A9oa06fU_x5TubYa457LqAwIDiSj7yGDQ,1339
+numba-0.66.0.dist-info/top_level.txt,sha256=lAjxwBJKjiuhWb3Oxtg12KVAHFHBvynjw2CXL-a00Ig,6
+numba/__init__.py,sha256=PPSYnQ3kvcwmJ_xL4H5Zia3nKsrUfmVRdxsBa7iBmwU,8674
+numba/__main__.py,sha256=Mr67cF_MTaSs9gZGD7paaQFE8dq62dXt6ixEI0Fo7dM,152
+numba/_arraystruct.h,sha256=SgoBWBXJODhp6giCY6b4joNSoF8TPQW_YB9-jsmkm-k,499
+numba/_devicearray.cpython-311-x86_64-linux-gnu.so,sha256=JLkrjOXBtviHMB2S-JKkVDGjre3mU_U_ezHraKPFTeM,45808
+numba/_devicearray.h,sha256=fnyiPxdF47Um9uiMEJL-1e8qg2ZdYMy6NHFifelktg4,666
+numba/_dispatcher.cpython-311-x86_64-linux-gnu.so,sha256=T1bj_VNDdEAYLUw-kiq2fIh_IgiSAvE9qTgw5SD0r3U,403480
+numba/_dispatcher.pyi,sha256=9sw_pA7RRgsg7QxcJt2v2zNRhDgfvMZKhLKuPfghaaQ,1887
+numba/_dynfunc.c,sha256=iRTgvlZ85iutFsabXEN0plsxzGt-5XO2kvLIKxgWFh8,20302
+numba/_dynfunc.cpython-311-x86_64-linux-gnu.so,sha256=PkiO-0wiqwnpc-GXyKfZS0LrlvXBeu15MFs4AkC5Nsg,49664
+numba/_dynfuncmod.c,sha256=xFiXbTRxFkU17_QPyOL2ybgDbMix5hKXM9Bic76BgSg,2635
+numba/_hashtable.h,sha256=74Dqe0BcBgs7X9R1Msv5BJhbC4LCi_34mNoUiBP5nlo,4499
+numba/_helperlib.c,sha256=BTZ_6uWbbRFHGApXAZhzH036fEqeNRG6HQmEZ6TY_hE,34823
+numba/_helperlib.cpython-311-x86_64-linux-gnu.so,sha256=mZnxZCoT25CTUSDCZnpi55Xcn-CyUfrrYh0f9eEHoqM,835320
+numba/_helperlib.pyi,sha256=PjsAh7ug-MenYDHWCX0s5nx3X2yGVHtFgsTkHoVpwFg,75
+numba/_helpermod.c,sha256=ehpOrcaa1yk5akXgOpLZs0WKjJCjt3GSfBEpfJYlRVk,7862
+numba/_lapack.c,sha256=Xn8uUHFgWJk8eVilo1byHazu7fGTm7AqILxApoAlsNY,55086
+numba/_numba_common.h,sha256=qcZMEJFdEH4y2BJ4f-FVV-gzoSV4BW-5xC-RaB_5e-w,1667
+numba/_pymodule.h,sha256=HqN4oZ7pXAxkKFoEn-fUTlrWj30Rp2p0DejJKovZqJc,1710
+numba/_random.c,sha256=xplDgTp5b_XC8SYgKSSdqx6HEdxfTJNv4f_EpSRcNOc,13152
+numba/_typeof.h,sha256=TL7gz-3EUTlq5YAzNxpHFMNCXglo1witOJTIlr520s4,344
+numba/_unicodetype_db.h,sha256=BK_cQfuPjJVk5hB8AZr7o0geNkHA7R1yDJvLw6HQtuI,248614
+numba/_version.py,sha256=Sv9tk0sHV99jd63fOlT4kuoS2k2hLD49SoERGRlBUnQ,498
+numba/cext/__init__.py,sha256=ZGFuefIViSAZpwX2PlttNOSKuubZ9afqDDN_35SYE28,507
+numba/cext/cext.h,sha256=BcSDh4LjinnWcIe1T5vm-iahaVu4Cph89rfdvDK5PtU,661
+numba/cext/dictobject.c,sha256=zI0HZ1VhCwiqvYVLqso3xILVUEWQV3kqFeQDH0LwKhM,38175
+numba/cext/dictobject.h,sha256=AEY_44GaiJsTyTHkZqG2JGiVoFOpNpMB94ZSD2nJ8fA,5980
+numba/cext/listobject.c,sha256=h1v1VGs4td4-1XQL7pb5TNAo9-tEntYgAjrFKIG6WHY,31928
+numba/cext/listobject.h,sha256=S2605_HlvaK03buI-SFTjEl4OqZvd93-kvOVxudrZxE,4125
+numba/cext/setobject.c,sha256=JvEpvP3Tk5sF--tYoU2d995zOjjyxJKozOD8vVjqP8k,29205
+numba/cext/setobject.h,sha256=2Ga48iRRjylMQTKaTgPaToK9WvOIidFNV8mqHUAHgcE,4339
+numba/cext/utils.c,sha256=FW9zwCwlZIQcge2d7KQlsFU2k6EcfcrY-rhn9x71vx0,201
+numba/cloudpickle/__init__.py,sha256=IzKm9MzljfhH-QmN_o-zP5QimTwbtgJeRja8nrGFanQ,308
+numba/cloudpickle/cloudpickle.py,sha256=AV4MEacCVSLzfQu1ldcxMM5egfS3BYQeIUZuFew0CjY,59103
+numba/cloudpickle/cloudpickle_fast.py,sha256=AI5ZKf2AbLNxD8lXyLDpKZyzeZ2ofFtdK1ZWFq_ec1c,323
+numba/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/core/analysis.py,sha256=WUuo8Fez3856YxXhNophQYlegY1tHAi74GLYcr7FcW0,28317
+numba/core/annotations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/core/annotations/pretty_annotate.py,sha256=_RiqUaNuc7cQwYit7z5NpvdxzYe5mPzNVjybXyhqVfM,9540
+numba/core/annotations/template.html,sha256=nU0wqR4YNRTGVTc-9JgpQvwMW9IFb4F-0GS17vvfdiQ,3464
+numba/core/annotations/type_annotations.py,sha256=O5j1DM5JZ-2BpTOP8CqI-D3O5tY0naog3-Xl7xBG4vE,11184
+numba/core/base.py,sha256=6Ij_GmY9wnzOhouL-iSMrvqoNnGLeqV0CWY8vHFwvG4,46144
+numba/core/boxing.py,sha256=3eOH-z0S3cKFpcj9X8eT1v9FCIDMbt53O4De8h4E_0w,46653
+numba/core/bytecode.py,sha256=J34EAuKyityUDQsb5JFvyP1jtSBrzWIg-ZT8KZ0cQpI,25041
+numba/core/byteflow.py,sha256=4J-mSKXVlVj4IPChGUsIsR8tEOECbvPQhicFewm0bfM,82552
+numba/core/caching.py,sha256=Am9G2GgXEf99T_mBxUIHU2Yw44y22PuGuE9BkWdGNcY,26855
+numba/core/callconv.py,sha256=gkLr-gEBpJHXdLPQDw0Y1A5HpjyBEcuumBnNQaPAZIM,36799
+numba/core/callwrapper.py,sha256=RxaV-p8315st3H5TfaAGidjvo8H04Lf1PSgtZlOSRAw,8450
+numba/core/ccallback.py,sha256=jfxSEbMKmbKVZfz3DC5S7p2oPnV3y3Oj8svwlP9SElQ,4312
+numba/core/ccallback.pyi,sha256=gOat0Gd7PMQkWjBhV87NHNbzWaWelBhSDzSqE2S9uX4,1488
+numba/core/cgutils.py,sha256=Z1fN3gcpVnhknzuv9TKwxyxMByiERJnrfqjA9UbbOYs,39216
+numba/core/codegen.py,sha256=gDYhiMiiYz4ezI4t-0VYh_5xdFAl7ufp9bvG4LEOm18,55456
+numba/core/compiler.py,sha256=qC867N-qi3iaeCI-CEkdxzrsOrjwD_TP-dN3bkzzEpQ,27864
+numba/core/compiler_lock.py,sha256=CM8ONwrW9UGLT_uQ3xpG5huU-M3XRAYA32hCLNnuTTQ,1521
+numba/core/compiler_machinery.py,sha256=-UuuVPV0-TSa3_xDDRRY4EI__qefNU0VJ96xjDcqpLM,14391
+numba/core/config.py,sha256=DaPamtpY_XEnMXu99L7j0iRSIikFFKvu6wPjtW71XIE,23052
+numba/core/consts.py,sha256=lkwM0wNPw9rjv9rcFsDufZESSo4fC0yeszec92O96ys,4501
+numba/core/controlflow.py,sha256=Teg-8v6GrmPGuWodMqGTfzvyJZWa_jzBxvv-iWTjkyU,32358
+numba/core/cpu.py,sha256=TDvZYI2pv_trn4pNe7EBLnRlqUCo_xfQVwZTihYWFwA,14189
+numba/core/cpu_options.py,sha256=FRc3PTrVcpf4UXpScsKZd_4XxLO_4Lb8SKCDRGPH_3o,5484
+numba/core/datamodel/__init__.py,sha256=uEqJC_eaDkBhrb1NZzU76hn5Zv5vtsPNxxic-wLd05E,225
+numba/core/datamodel/manager.py,sha256=OFSk3zpXbt0rOTHCEudW30cwn90uqhAIShd65n8Wa2M,2155
+numba/core/datamodel/models.py,sha256=xsgTKns0M7OsRD2Jctn81mmhYfY9hueczJEndpMGXyM,44199
+numba/core/datamodel/packer.py,sha256=PK-fWl1nBm2BpJwd7PMswTYACgWm41bHhkVh9CNTgBw,6645
+numba/core/datamodel/registry.py,sha256=uEJyukeEvGfyIovLfBO3Rr6maqLWhgK9msD1hg7fKmg,416
+numba/core/datamodel/testing.py,sha256=f31La03lzPAPGPF-OE-VaV-rLv0h-BT9rmRFElEDIco,5346
+numba/core/debuginfo.py,sha256=7UGcm8gFOMbO5wXWQjL9aWNdx-6_XPaxk_ANFhsKElg,17525
+numba/core/decorators.py,sha256=yan8ldffqh0aAZHIfqNmzCxr4PlOwJ0atYD2XdO9yso,11360
+numba/core/decorators.pyi,sha256=WWoH-rZK_xZFn4Xu6F7D5rgJvUgtQBa5Z1pezC6SR8Q,3446
+numba/core/descriptors.py,sha256=pYBrPowcj7MJob32fdZZ2WrmL4NWr69GPBsl0_QaqIA,345
+numba/core/dispatcher.py,sha256=n9BQsQlc1qn--QdyqgZdUTKFg7FntSOT975rYVuZlTs,51622
+numba/core/dispatcher.pyi,sha256=n4MyBtHs1Ngy0ZA-Im-7IYHHtM2cjpoDXZbyf5qFs78,7877
+numba/core/entrypoints.py,sha256=eZkSqheZj4WuTVy0cjApQCQXs9rOxoNGXZ3PcuxDiGU,1615
+numba/core/environment.py,sha256=wCydbj-gUqqy0Ql_RFmHBazk7Wb722qa71SIQRRve1c,1639
+numba/core/errors.py,sha256=J-05z7xOTkDKKMy8twJk3uSV6pLLgxToUsAXUkD1cCs,26257
+numba/core/event.py,sha256=q4eNSV-FMnlL_jbzm51sTiVqu2acj6e74qiPBtC0ong,12095
+numba/core/extending.py,sha256=aoNvWN7H6ectEJWXmsDfrrh4jhI2OnlTNwiKXhrv26c,19779
+numba/core/extending.pyi,sha256=y4HA8eLcgptr34pjWr5AaJVY1ATCGXe0GIAPbGAYK9A,6097
+numba/core/externals.py,sha256=Dwxc71cCdcizy-_TZRR849eDMzNOXa1Y_KSZ8tUoCVI,4851
+numba/core/fastmathpass.py,sha256=0HQfDhMmdjKG-tTiqeoYoUtDDP6CZIEPF7pGZnbDIRc,1211
+numba/core/funcdesc.py,sha256=1VX9EhGiUTxD8ixQhC6GlXOzj9HxEpsYhf_RxLyeOR8,8273
+numba/core/generators.py,sha256=KsHYH7fC6mKrYNMFHZ4hekK8gQN0W_442QECsIOe3lU,14176
+numba/core/imputils.py,sha256=YocYwlXMYTkQqJLYcEj10v-nzIj4Dn9sMiCWBcM3dmU,15895
+numba/core/inline_closurecall.py,sha256=QDm1np0ZsyhkNQu8nrVR2eY31xFkVgSLejOHylBWSfw,72191
+numba/core/interpreter.py,sha256=HhJuPFXOa1WQ6Sf-KeZZYm_JFDjBQdAtE-Y-UPwFGx4,143235
+numba/core/intrinsics.py,sha256=IZqjKTPQ_74XdNGt3-WurTKTfgEhGVkfhPSwdv0EpSA,2008
+numba/core/ir.py,sha256=5sgGHOy2XmgWjT7xPNLARsiTnee3Hy5xbPhUyHV_Gmk,52254
+numba/core/ir_utils.py,sha256=bTZjmTDwUd0qHC1Xr-bVntuXKEkaE1TQX_6j-scmM3Q,89748
+numba/core/itanium_mangler.py,sha256=ljbaWNE21eKYVnaQovhxP_mjsM1xVLilu7CdjVYTDyw,6110
+numba/core/llvm_bindings.py,sha256=5gZWzIsJZMWNuZZYUDrOU-Y8_3ZxYe2Rddd26uaAOho,1245
+numba/core/lowering.py,sha256=OokX2m346J_C0L43jhNxQ8SYKpIpzTYjygl-J_bFLmA,67046
+numba/core/object_mode_passes.py,sha256=XeRInu0p6iWhfthmFd40wDcqjvM9AGcd6SpE-dzS6Vw,5869
+numba/core/optional.py,sha256=5g0Bgn4pB09yyVOP5X973f-RpVrKA1Y3l40PlJX6gd4,4182
+numba/core/options.py,sha256=QISFK5LSWEBZkl6EpOa7rWStaKrChgZx39xtskvHoEQ,2999
+numba/core/postproc.py,sha256=2DWTz4PvcPQQTj7y_L30ij1sII3OKt0l0K_azsFGLFM,9318
+numba/core/pylowering.py,sha256=OJMzHwCusj0Fa-qIR94bNVSuIJTcL5youagB6yRl8a4,24891
+numba/core/pythonapi.py,sha256=6Nx5g3NXfyxW9jY7puVd-83z-up0MOmT3p5DJ1tOvBM,69573
+numba/core/registry.py,sha256=H0eAEHnO392xVxYpJ65gnmWsppVC_L8aCV_aDnDYl10,2625
+numba/core/rewrites/__init__.py,sha256=nYQr5fLoOWzeeWbP8AeQnWij9nAoAMkFG-B6gjJ7d7E,284
+numba/core/rewrites/ir_print.py,sha256=TXGMw9NziDSAYxc3SguhdIU7Pn6NQP9X5umlAvlm14U,2969
+numba/core/rewrites/registry.py,sha256=0vubYnbutEygNYiNEbvm-Mf9mP977giP83QHBiSeKBA,3651
+numba/core/rewrites/static_binop.py,sha256=beLhF0A5FyoDKKS84jsNvMOgQAFeEWckm6z-rrI-8Bw,1146
+numba/core/rewrites/static_getitem.py,sha256=OmYFspFKSSk63fVwV2Oj8Wu4ZhVRt0rQR_E-rg_V3ZM,6624
+numba/core/rewrites/static_raise.py,sha256=aBHSyB_Djac-T2gN44aiTwBKCIDVb9h_Mv12qQF62zY,3576
+numba/core/runtime/__init__.py,sha256=g0oEnSA15s0XLF7kuPp_U7pw5KUcnZjcDdF0gD51rIM,23
+numba/core/runtime/_nrt_python.c,sha256=UzNLXbDiLxsA_AtzQmF2Vht0a7jDoHeaIQxEAiWDWo4,15158
+numba/core/runtime/_nrt_python.cpython-311-x86_64-linux-gnu.so,sha256=tLpDebMZfb3Or83OVbz4hkyMWPLLCIj5vEo5xdT4hAo,189304
+numba/core/runtime/_nrt_pythonmod.c,sha256=Gk3pLk3R96W5gHumuJ1eg2N-eXeNOlrsWPNbtQMBht0,6095
+numba/core/runtime/context.py,sha256=JP80DuPKWT9P0qsXay6ueHYuqtv4ChyeyDRBbMJuqLA,17206
+numba/core/runtime/nrt.cpp,sha256=6HoAZuhcuagbBJXvZP2A8o522kYZGhwcG8NZfI2CP_0,18525
+numba/core/runtime/nrt.h,sha256=JJzmIotXg2otcSudPYPud6Wsl6fbJdSX_7M2rGJ0rH0,6453
+numba/core/runtime/nrt.py,sha256=vwfYk5NSKCqbTDX7ylE5_6P53Zjo7Zl7R_i2v1JVMCY,4071
+numba/core/runtime/nrt_external.h,sha256=q2IkdHTFlV34qrQlkOL1BJrosG-4a10vxBDcyQR_iHg,1865
+numba/core/runtime/nrtdynmod.py,sha256=Fi8E1Wqu05fc_oUtXXqbPQk_xepLoq1ydGFQrb1-a6U,8002
+numba/core/runtime/nrtopt.py,sha256=OUuVG7DznCbJI6Xhwn3fLCucEbZ6nhimogNzduEQYho,5834
+numba/core/serialize.py,sha256=9iKgtD-widcUcCzAT745hF7hka2vq9R5mheuysOAGAY,6284
+numba/core/sigutils.py,sha256=KpoyuVJ5RGgtyMK2cgzmN0P3pU39zU1M-NbxSai90d4,1613
+numba/core/ssa.py,sha256=0grM2SdX_vZjpD540O6I_gHZMzN57aRjyeFfDneF5JA,16546
+numba/core/target_extension.py,sha256=CJlJ3nb3YlIYybujExLTEFT2cO5kItqIay5Qgc6Sm3s,4606
+numba/core/targetconfig.py,sha256=TOH0CFU0XkiPuhEoVRrXTPTPnTi9FCSC-3wYurVjB18,9817
+numba/core/tracing.py,sha256=C4HYOC8IgIq7tNReI3jnkfFZhA6WQbVVrG8HcYpNNXM,6900
+numba/core/transforms.py,sha256=TVea3D-BmGPdokZUqv3_IGZxLkAbi8JEezNP5hCbpC0,31846
+numba/core/typeconv/__init__.py,sha256=KrF14DtWGRNjGJwRsBVGcsCNWEBQ6PqLg5o_6sJSTEM,34
+numba/core/typeconv/_typeconv.cpython-311-x86_64-linux-gnu.so,sha256=H5j_3UkKnvx8b8cYR9AUkwBVxztfvyE6vZq4cTbqJuc,139624
+numba/core/typeconv/castgraph.py,sha256=jSG30D_rPtiUZuQFFnlCG4N3VG-7pmMwmrtNVI0NS2A,4075
+numba/core/typeconv/rules.py,sha256=gEPmSvxvqeewigyxwVvYZMowBA5zeYKaThJs_1IiHaU,1933
+numba/core/typeconv/typeconv.py,sha256=vcRNg8FkcWb_xdJ6IprQ_Hv8ANjArgNBrAOJCaEzTfs,4365
+numba/core/typed_passes.py,sha256=8ojaLRXuimDQICdb1xhzL838jHwofB3Cm2dKFUyuyVU,38835
+numba/core/typeinfer.py,sha256=0s7oZtUcs_xLk8q18c53d_e6BIUQ4pWi5tXnrKqpxdU,71738
+numba/core/types/__init__.py,sha256=RWlAXx11IVxf5_z1sgbdcNIPTVxrU6sACfxv8Bo2ewA,5467
+numba/core/types/__init__.pyi,sha256=Xx4pSubyfPnxLn9QfiIFGbiLCcKPQGUgqyq3aEK2PBo,5195
+numba/core/types/abstract.py,sha256=IzJsLCR6zXOr0_smA9sLk51MKdj5d2K9BwVASjDiw5g,15202
+numba/core/types/abstract.pyi,sha256=7ALq8oQU7_fkiVSPEv0BuGAfEo0JR6PFkgQ7aUAaYK4,5199
+numba/core/types/common.py,sha256=lcBWBAXAxtVs81G4cLzjNoXnSuvhd5newMwrJLuKxQw,3022
+numba/core/types/containers.py,sha256=5sXX8gT749zChqy1exBKSP-nePK3pqGLLrsAGkLWe1U,30661
+numba/core/types/function_type.py,sha256=wWskEdTuvm287ZZwRdvff7dQ4yZAGVDBmANPIlWnf3Y,6551
+numba/core/types/function_type.pyi,sha256=5LNq8bmO7QEXqFi49iFNv78dxzwOVXirYq7DNR02Nt8,2928
+numba/core/types/functions.py,sha256=HUeUR4vtMcKcNQ3SuTkXEqVdE1qbPFKYLgWd2foovgM,27070
+numba/core/types/functions.pyi,sha256=BWSY9ZlFAmIPNlJnYkazwlOVSlStVHK4Lzm4Z3TRmUs,6576
+numba/core/types/iterators.py,sha256=Byq2QyPRSTL_Z-xeUJKljd3anzDny8CN1TEp-YmqISw,3534
+numba/core/types/misc.py,sha256=NcljFVerH2tvV-o2n0uWM0d53Tp91Wp3BWXmBPGgISk,14609
+numba/core/types/npytypes.py,sha256=Dko5LsKPeqyD-AXg0yKj_unnBOPPCDjaCf1DtOZPMsA,20597
+numba/core/types/scalars.py,sha256=BMdujcaS37ZPx_i-5TIeMimtem_cZAygWQu0sG26uBk,6155
+numba/core/typing/__init__.py,sha256=FD8n9EBp1Dd65qpibBRAYoGMkRy-U1snNitmaSceyLE,152
+numba/core/typing/arraydecl.py,sha256=okPFJ_b4VR_ZbPAHkAAoTql4Bt6ypQMYaHhLVmUCI1M,30984
+numba/core/typing/asnumbatype.py,sha256=ypov7bYOta9bEyhSgL-wQSV_30_1QWYyo_3VnvGKVn8,6487
+numba/core/typing/bufproto.py,sha256=f3aQVsiwmjTrhHkdviQB781AAhWbhTpuY7wCWK1VqyI,1719
+numba/core/typing/builtins.py,sha256=zhzkOZqX38byPrsk7WmkR9kZdB_tPeDe95yfNomywlM,32960
+numba/core/typing/cffi_utils.py,sha256=L8cafV2eHiNyi9m9EaFUzzb0rLy_R65NuEjAovFuE_I,7959
+numba/core/typing/cmathdecl.py,sha256=J7F_fnavUrRcuwgVNt4XrsoojCBZ_K-CNryk_3JY5eo,1202
+numba/core/typing/collections.py,sha256=WDhsPKYV7QUd5ACfEd8zJphvCyPLSj8eb66EhFGFNbg,4025
+numba/core/typing/context.py,sha256=LS4UvICvjQiMvKiZ82PISAlrJOHaxRKsBq6VvMEM2mM,28633
+numba/core/typing/ctypes_utils.py,sha256=053rG2hVZ4jMYxiaUkIi0jFuZLdqO3N2MM8NsbeLCLc,3623
+numba/core/typing/dictdecl.py,sha256=-rFhnPbP140Sy_iaJufIP5gtE8Hd61rzoHNb5lKbDZk,1872
+numba/core/typing/enumdecl.py,sha256=W9ugyhgCumA6WLM8HG9nKndU55sYal6KB28Afa47O-A,1503
+numba/core/typing/listdecl.py,sha256=mYRdzNLhAXScEj8-ldr8xSzA1rsmmY27-SonQOJTH3Y,4494
+numba/core/typing/mathdecl.py,sha256=JSeZ-PFZf0JWWWttmDidTE7HJ3PkvTCrYOH7mRtxgVY,4488
+numba/core/typing/npydecl.py,sha256=FtNGf-kGNgKZUVYLHNERjTS7bT6B9eubaMkq7huufjQ,25202
+numba/core/typing/setdecl.py,sha256=YugeSIfastKRzE5N098jUBDeEscYiKxCrr69_cDYd9g,3209
+numba/core/typing/templates.py,sha256=dhpwzt2Iq1CxbWF0Ig_1HLq4VGLxWb_VlbL77DzNSvE,49841
+numba/core/typing/typeof.py,sha256=RPXZ4K35ddFpfL-DBQ13d1WN2ZshLcwtvk5pMxlD3DQ,7743
+numba/core/unsafe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/core/unsafe/bytes.py,sha256=2X-_9etm5LeGkKOgOR9T5CezCydxZtDstHNookgOfoA,1720
+numba/core/unsafe/eh.py,sha256=fDSxnbGv5xTjGk8dj0M4hiJoySxbUNdKEhIVCOUiK5c,1621
+numba/core/unsafe/nrt.py,sha256=3voPFKB8jZdLq8bm05_USvS6xhBerF6G7sz8uC3CHxE,468
+numba/core/unsafe/refcount.py,sha256=hYVRt3Aw2iaXX_rvB1a1tYMW-9YtFi3G5Dvx3SN2n3s,2704
+numba/core/untyped_passes.py,sha256=nvkhsDKRCuTcdiB1XabPGXRcObttdqrpGuq0l7Ugxr4,74871
+numba/core/utils.py,sha256=8IMf2nypU7i5m_5ddZdMiaupReAWpBvTSTc4TXd-ehs,22535
+numba/core/withcontexts.py,sha256=Y1AFOz5CqPXShFOdN2iRWNH9QgXbBpHRkKi8oC9rMds,19133
+numba/cpython/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/cpython/builtins.py,sha256=tQCfXFcTqyWIl5qZjW1pBHVsaectH_1ji4Tbec7QmEU,36688
+numba/cpython/charseq.py,sha256=cZD8YpJNq_YWL2g7irQQW456oTDfMUowmQbHlbvw7bU,34401
+numba/cpython/cmathimpl.py,sha256=FtDWq6PtOUTZMZ4k0K0JOgmEpUZk0wM2G0-aRBTL2ME,17607
+numba/cpython/enumimpl.py,sha256=nGDz9MdYT0Zmy2En_VoyT5Aq_9-0mV1qNl1MdzbNwIw,2906
+numba/cpython/hashing.py,sha256=Jf0uvGv3-envazAV96ury6Rv1l2jKppX4ZGlpHlWrM4,27042
+numba/cpython/heapq.py,sha256=v4AIbYVfPkAcqjcxN1r9RyIOIyqeek4UzOiOJftUYqw,6185
+numba/cpython/iterators.py,sha256=WexsScJ2DuWoTe4qlbflra8ICYXWo4umsbFzawubBuw,4897
+numba/cpython/listobj.py,sha256=NPAzbz-0WQd3hxR26Rb6wxBSK3JvVhDz-U5KFiuUwy0,42815
+numba/cpython/mathimpl.py,sha256=OcVY2A2T6voRxPG7Efl5DZ2_aa_OFTavsUs2UjbomGY,16199
+numba/cpython/numbers.py,sha256=ceZamnqV20XTjSUk-L2YjwJlP2ZL8nIlP73Tgu1bxA4,50161
+numba/cpython/printimpl.py,sha256=-cL-3akbIhdtSVW2dW6p3mjDvLBzCHc6NxRoKR07ETg,2494
+numba/cpython/randomimpl.py,sha256=yojNOBBjnieh1aek1aR0JD5x1AizY-ngNlF9uN9kUvI,81555
+numba/cpython/rangeobj.py,sha256=ZK8ng2sPsLhnrNRwYbdOzbFEkP6LAxfWaztQJn1DgQA,8653
+numba/cpython/setobj.py,sha256=Wo4TmkOfyaV2NfBYMMxhAGK3L4ZWTMMjYKEf_Xmo1BE,57246
+numba/cpython/slicing.py,sha256=BJIh9WSWE5hksbkjpNJFclfofEXSkvB_kLYNGcrWk0g,9435
+numba/cpython/tupleobj.py,sha256=t2O4PHan-zGDBxT7fnlta9BIrYSpewbkrA6v6z8SN_I,16855
+numba/cpython/unicode.py,sha256=0iZMElB5Kx2jufw1423lhBfY8vPHxBCeUT4SQ47hSUY,89951
+numba/cpython/unicode_support.py,sha256=2SpAMVq25CdxHX2E8tbkFbCEQs9-9Rsw4T91BuvWHz8,27323
+numba/cpython/unsafe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/cpython/unsafe/numbers.py,sha256=99pqDh2kEopxjAX8H0GZ3RFNV0eFMnMWjp7g6qwM7mQ,1719
+numba/cpython/unsafe/tuple.py,sha256=t2IJz9N3DzBbgE5cy6g5dWAZ17a3Td9PDNWWHsp5aWY,2883
+numba/cuda/__init__.py,sha256=dVzRg7REcZRsrS8h6DSsMjij418I281Mha1tYhwO5uo,620
+numba/cuda/api.py,sha256=e9Y7RQWh8mEl3Eie3xzgniSgjHC_nlLrjBCiYx5pNs8,17601
+numba/cuda/api_util.py,sha256=aQfUV2-4RM_oGVvckMjbMr5e3effOQNX04v1T0O2EfQ,861
+numba/cuda/args.py,sha256=HloHkw_PQal2DT-I70Xf_XbnGObS1jiUgcRrQ85Gq28,1978
+numba/cuda/cg.py,sha256=9V1uZqyGOJX1aFd9c6GAPbLSqq83lE8LoP-vxxrKENY,1490
+numba/cuda/codegen.py,sha256=raBoCDNt_qkDgB12yU0tbJQlA5_eTlUMemgcRHen1Vk,12174
+numba/cuda/compiler.py,sha256=seanDEVVsiBqGmHUivIxcYf6mPWEgPYam1rects5-vs,15886
+numba/cuda/cpp_function_wrappers.cu,sha256=iv84_F6Q9kFjV_kclrQz1msh6Dud8mI3qNkswTid7Qc,953
+numba/cuda/cuda_fp16.h,sha256=1IC0mdNdkvKbvAe0-f4uYVS7WFrVqOyI1nRUbBiqr6A,126844
+numba/cuda/cuda_fp16.hpp,sha256=vJ7NUr2X2tKhAP7ojydAiCoOjVO6n4QGoXD6m9Srrlw,89130
+numba/cuda/cuda_paths.py,sha256=_fPrwCysDSoxwUvU_2xyGe9KSDxtHzunkxVqQNLtTBg,7723
+numba/cuda/cudadecl.py,sha256=ynUidit8oPGjedc6p1miMGtS20DOji3DiQHzwmx6m0s,23192
+numba/cuda/cudadrv/__init__.py,sha256=0TL4MZcJXUoo9qA7uu0vLv7eHrXRerVmyfi7O149ITw,199
+numba/cuda/cudadrv/_extras.cpython-311-x86_64-linux-gnu.so,sha256=UodF7nO0p1mvsVCUiX4YYjmeyt4VKfDPqDxS6Mperm4,25856
+numba/cuda/cudadrv/devicearray.py,sha256=B3ItYQywTnwTWjltxVRx6oaKRq7rxTtvOaiqTWsMQ2w,31123
+numba/cuda/cudadrv/devices.py,sha256=6SneNmoq83gue0txFWWx4A65vViAa8xA06FzkApoqAk,7992
+numba/cuda/cudadrv/driver.py,sha256=vX3ayUtG0iHgZJRdIWfY5GvPGnskRBVMJvDyo4s1Hgg,107039
+numba/cuda/cudadrv/drvapi.py,sha256=gDalZLaZBRQIDU-LUXgV7MwPJlgKuiu8h0YEcTA6_SM,17129
+numba/cuda/cudadrv/dummyarray.py,sha256=nXRngdr-k3h_BNGQuJUxmp89yGNWxqEDJedpwDPEZ44,14209
+numba/cuda/cudadrv/enums.py,sha256=E0lnh17jO4EvZ_hSIq3ZtfsE5bObmINtKb_lbK7rmMg,23708
+numba/cuda/cudadrv/error.py,sha256=zEIryW6aIy8GG4ypmTliB6RgY4Gy2n8ckz7I6W99LUM,524
+numba/cuda/cudadrv/libs.py,sha256=PRyxal4bz9jVZmuLpKiYw-VaR59LekfwJgWKo7R5uRY,6005
+numba/cuda/cudadrv/ndarray.py,sha256=HtULWWFyDlgqvrH5459yyPTvU4UbUo2DSdtcNfvbH00,473
+numba/cuda/cudadrv/nvrtc.py,sha256=CLpuD9VzPcYoXj8dZ2meSoqbWXHOOC5V5D6dFNdXqmg,9693
+numba/cuda/cudadrv/nvvm.py,sha256=v2hJJTAQeRmoG59-hnhgMEp5BSVA73QHtEoy636VKao,24107
+numba/cuda/cudadrv/rtapi.py,sha256=WdeUoWzsYNYodx8kMRLVIjnNs0QzwpCihd2Q0AaqItE,226
+numba/cuda/cudadrv/runtime.py,sha256=Tj9ACrzQqNmDSO6xfpzw12EsQknSywQ-ZGuWMbDdHnQ,4255
+numba/cuda/cudaimpl.py,sha256=3YMxQSCv2KClBrpuXGchrTNICV1F6NIjjL2rie5fDZ4,38628
+numba/cuda/cudamath.py,sha256=EFNtdzEytAZuwijdRoFGzVKCeal76UzzaNy7wUFQx8I,3978
+numba/cuda/decorators.py,sha256=3iN9e38Qt4v7P_TfN_G9AR4m-YBWooHsdX_TcJz1ToY,7854
+numba/cuda/descriptor.py,sha256=rNMaurJkjNjIBmHPozDoLC35DMURE0fn_LtnXRmaG_w,985
+numba/cuda/device_init.py,sha256=orQK7anhnmEkYPRjHEs5I9uhdBwaHeXbaSD4ViX2_14,3460
+numba/cuda/deviceufunc.py,sha256=Avu9hTiUqXrgzltNocZecvFtVxjtSP2GtG03N82BIk8,30955
+numba/cuda/dispatcher.py,sha256=wCq4i86OPMOD5-dFbUYsQhmka7toJ6Rqh8jD0PtAPQg,40241
+numba/cuda/errors.py,sha256=XwWHzCllx0DXU6BQdoRH0m3pznGxnTFOBTVYXMmCfqg,1724
+numba/cuda/extending.py,sha256=URsyBYls2te-mgE0yvDY6akvawYCA0blBFfD7Lf9DO4,142
+numba/cuda/initialize.py,sha256=TQGHGLQoq4ch4J6CLDcJdGsZzXM-g2kDgdyO1u-Rbhg,546
+numba/cuda/intrinsic_wrapper.py,sha256=zbcUbegbfF3GdnC2Rl-z26-gozE8xBtaMxpS8LpOhfo,2239
+numba/cuda/intrinsics.py,sha256=zk7KCyzRyXlBpxwEJLg_3oGRXOA7bODX4RPEsMKns9A,5983
+numba/cuda/kernels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/cuda/kernels/reduction.py,sha256=fQnaWtoNB2yp143MNbE1DujqFIYy0KV_2moQVvbaROU,9362
+numba/cuda/kernels/transpose.py,sha256=5FSu-nbTfhintxwfU-bjT2px2otQF5QkKH-JPDDWq_k,2061
+numba/cuda/libdevice.py,sha256=476LeIEaAth409m-0OO1SMMmY5AHzN2AotXI__k_yYE,60065
+numba/cuda/libdevicedecl.py,sha256=xdZbb_rCaftMf8Pbw63g_Lr230N-1QoaYzBxq8udKTg,532
+numba/cuda/libdevicefuncs.py,sha256=c80lGpGoFIYkAdgr4fzbxzdNCyJYrLdss64bwa0Mc6w,37471
+numba/cuda/libdeviceimpl.py,sha256=a9BmJ5kRtZ_mB7KjbDWW-PEpRuNiO_SMOxQTyy0abqs,2806
+numba/cuda/mathimpl.py,sha256=d_gCoQ4hJzNBFNc2hvRON5h1F052epgQ8zh_RKTlLlI,14416
+numba/cuda/models.py,sha256=2c_seT-cWX-VyWYmcapaqOEl1M4FX6_kdIOusj4s5aE,1328
+numba/cuda/nvvmutils.py,sha256=W1zr1TpnmFjTkHF0qeu5wnBHub6gzrnpzsvgmu2OLcU,8295
+numba/cuda/printimpl.py,sha256=Eg_RvmOcmFeL6s2RlTD-oOxebGdYLN9VZM1gcY3YMms,2789
+numba/cuda/random.py,sha256=khX8iDdde_RTUPWhAqrxZacHRQAorFr7BokPuxRWzrg,10456
+numba/cuda/simulator/__init__.py,sha256=crW0VQ_8e7DMRSHKoAIziZ37ea5mpbh_49tR9M3d5YY,1610
+numba/cuda/simulator/api.py,sha256=_O9lox-obYn2j4843uZ2hZjIWgu7PXSqQGy3EiSwnnc,2620
+numba/cuda/simulator/compiler.py,sha256=eXnvmzSKzIZZzBz6ZFJ-vMNyRAgqbCiB-AO5IJXuUyM,232
+numba/cuda/simulator/cudadrv/__init__.py,sha256=MC6WHlTloHxGen9kIpH1Hp2p1PPyCNmoK5f3K9f7jXA,135
+numba/cuda/simulator/cudadrv/devicearray.py,sha256=brhVnaKiJFIvZbNlE-3yft_YXTmNm4S8s95VXWT_nMc,13789
+numba/cuda/simulator/cudadrv/devices.py,sha256=RYvLHarMNeHNrCYFokxXtg1nBIDRMu3ZohQ82hLQXN0,2689
+numba/cuda/simulator/cudadrv/driver.py,sha256=mRz-PV4lqc-Mg3w5yUJWdrj0XS_d-3CM93uI2ZR1MTY,1124
+numba/cuda/simulator/cudadrv/drvapi.py,sha256=76gXxRAQgr8bU-m8XizvqyXyXAZWp6QhUnS6rI-6E6Q,111
+numba/cuda/simulator/cudadrv/dummyarray.py,sha256=DYIpIehz3cZSane651UYdJP5fehDuJkxyCg_90A1heU,163
+numba/cuda/simulator/cudadrv/error.py,sha256=ACSQ7ZvhuCHnvV4GmvRuKWZ5bBLVzq7ncZ75oiWyLdM,87
+numba/cuda/simulator/cudadrv/libs.py,sha256=ry5rerpZrnAy70LU_YBa1KNaqKBGLHE9cMxljdSzaik,101
+numba/cuda/simulator/cudadrv/nvvm.py,sha256=vIFQi4ewYXyzUYssfw78QLfoZmoVgloFCLTk55Gg1tw,474
+numba/cuda/simulator/cudadrv/runtime.py,sha256=K63p7puZJZD3BQ6ZT0qoII_Z3xJiUckp2dhozFjrnEs,358
+numba/cuda/simulator/kernel.py,sha256=KzGURMAjrADWHE-1gUSfrKxWtwJGlH_pp9a1yxiPeBI,10668
+numba/cuda/simulator/kernelapi.py,sha256=ZYC_XQqnA51TJCPlAjVHHkOjXeww0yUP6JZeibXw3T8,12397
+numba/cuda/simulator/reduction.py,sha256=jVo9YiWv8W2CN5_oQ-xdS3nuxv1HZmWh9O-Vck8hsQc,300
+numba/cuda/simulator/vector_types.py,sha256=I18mACvWYjmCiEhcRuBfX4yDbN4XhmkDfXj3HRa303Y,1672
+numba/cuda/simulator_init.py,sha256=W_bPRtmPGOQVuiprbgt7ENnnnELv_LPCeLDIsfsvFZ8,460
+numba/cuda/stubs.py,sha256=a9smsDwbimTKy0YnV88OkcbYqldMgkx-WiV8LB4-MGs,22280
+numba/cuda/target.py,sha256=EI6XuKQeqvng0uSx_V9jDoxbgFivqSz-4jczFzAbs5o,16837
+numba/cuda/testing.py,sha256=E0wP2vfno1yWsl0v1zg31kpbU8FrKxTF-5y9Iv4WjA4,6412
+numba/cuda/tests/__init__.py,sha256=lvnEpX0TruMCga3PnDpryR3oVxLwOMyTyZKgMINCerg,984
+numba/cuda/tests/cudadrv/__init__.py,sha256=KeAvH3QOb-KXXkFtzwvYkQp2ZrQmzgfKDkBCVIOKXXE,257
+numba/cuda/tests/cudadrv/test_array_attr.py,sha256=cjHQ0J6F8APrLm23ZCFr0S7dtQmLqwq9vxMoI5lyn68,5300
+numba/cuda/tests/cudadrv/test_context_stack.py,sha256=lSEuEM7x-x95m_lS_wSIBKnBxOhzn-AJ3WjYw8bW0y4,4492
+numba/cuda/tests/cudadrv/test_cuda_array_slicing.py,sha256=RVFiuTx5wTFBECzEolJqquhfWCD6BlrK49IPyDPdmY0,14112
+numba/cuda/tests/cudadrv/test_cuda_auto_context.py,sha256=Bhut5gxKb8H-RNu8LKp0nEmyQT5FZVRA-aOrV6X8h3E,564
+numba/cuda/tests/cudadrv/test_cuda_devicerecord.py,sha256=rikIJQ266l_yiSMoncEeKJZizYdoVOiTg1R0gD_1nZY,5766
+numba/cuda/tests/cudadrv/test_cuda_driver.py,sha256=y--0AZFVpp2nmbeI1jbgZsWbBP-iVEmG8WKgR9XrxKE,7663
+numba/cuda/tests/cudadrv/test_cuda_libraries.py,sha256=sqNbo8pk4Zl5ptuGXrXFndia4IyttbuGnqjVTOtGuuw,801
+numba/cuda/tests/cudadrv/test_cuda_memory.py,sha256=MDJMIWm1jCsBOcuwdshzqwaE__uqX0562uSjxFhud3M,6627
+numba/cuda/tests/cudadrv/test_cuda_ndarray.py,sha256=67dmVO6v5gzp89pgb4wpxqDrWAx1UjX4vhdDQH4mebQ,20403
+numba/cuda/tests/cudadrv/test_deallocations.py,sha256=BR1ccEj_TCVToHoHS8KwwCfKLMUl6KGb92Cx6nX-XPg,8404
+numba/cuda/tests/cudadrv/test_detect.py,sha256=lCt2E8gxnd8O-fRobDEwgX4jBZ15W7cImQcZc8_u2Sg,2774
+numba/cuda/tests/cudadrv/test_emm_plugins.py,sha256=ah82yaWFvBfUTTSfbkZBKLsUf2tTSSJNvlSxrk1RI1E,7094
+numba/cuda/tests/cudadrv/test_events.py,sha256=rjBrFDxZUpfwRkAGMvMEcdjOQ7sKB_94Spv1ccxTCjQ,1075
+numba/cuda/tests/cudadrv/test_host_alloc.py,sha256=1zGjcSFSym-LZ7XQwlOPalU-GjTOYUOEPTeSG4iNQhI,2181
+numba/cuda/tests/cudadrv/test_init.py,sha256=kPbjDhLJr1Rl18UJZoGpT3E0l9Cm-HcyPRbKr-BD7L0,4493
+numba/cuda/tests/cudadrv/test_inline_ptx.py,sha256=eMImGlfYRQM5esoFhWHOwDGYK3RuXdrNvStURwcFDlc,1287
+numba/cuda/tests/cudadrv/test_is_fp16.py,sha256=0KPe4E9wOZsSV_0QI0LmjUeMTjWpYT8BXExUUsmUCDI,394
+numba/cuda/tests/cudadrv/test_linker.py,sha256=_l2_EQEko2Jet5ooj4XMT0L4BjOuqLjbONGj1_MVI50,10161
+numba/cuda/tests/cudadrv/test_managed_alloc.py,sha256=kYXYMkx_3GPAITKp4reLeM8KSzKkpxiC8nxnBvXpaTA,4979
+numba/cuda/tests/cudadrv/test_mvc.py,sha256=984jATSa01SRoSrVqxPeO6ujJ7w2jsnZa39ABInFLVI,1529
+numba/cuda/tests/cudadrv/test_nvvm_driver.py,sha256=VTw8-TZ7DvjNEqsrzZ-RKKzLRiSKEyAAZ3pRDYEQiVk,7252
+numba/cuda/tests/cudadrv/test_pinned.py,sha256=u_TthSS2N-2J4eBIuF4PGg33AjD-wxly7MKpz0vRAKc,944
+numba/cuda/tests/cudadrv/test_profiler.py,sha256=MQWZx1j3lbEpWmIpQ1bV9szrGOV3VHN0QrEnJRjAhW4,508
+numba/cuda/tests/cudadrv/test_ptds.py,sha256=S8y-j_ZB4Y_r2S5GGtfFxfracnJflQAhHYfhybKIcUE,4949
+numba/cuda/tests/cudadrv/test_reset_device.py,sha256=tPDkdkqNZEix2dLqe4UBcsejhauAc1oEQlrZDtPKWFE,1073
+numba/cuda/tests/cudadrv/test_runtime.py,sha256=h4ZIHkZbDjoZhgvFUWVfwWcktkgkoHMuDJq6SWn6hXc,3071
+numba/cuda/tests/cudadrv/test_select_device.py,sha256=DjfS3hGTDRFAQsk7QiH-v6-_1HEdaLeSyTiquwUPCTM,987
+numba/cuda/tests/cudadrv/test_streams.py,sha256=Yyzj1riNWRKM4FX3CtbMOQ_LWp92M5HXW6g_aq2r9Oc,4195
+numba/cuda/tests/cudapy/__init__.py,sha256=KeAvH3QOb-KXXkFtzwvYkQp2ZrQmzgfKDkBCVIOKXXE,257
+numba/cuda/tests/cudapy/cache_usecases.py,sha256=Cm2YupAQE7IFsiHp4TnC9kb_CLXGFMEK4zMaELrktIk,5834
+numba/cuda/tests/cudapy/cache_with_cpu_usecases.py,sha256=xm035XOas_2AXORGEQHz7hcDuXwL-bdpy3gL5AKp6ik,1142
+numba/cuda/tests/cudapy/extensions_usecases.py,sha256=l-tW4F935zxOvKb1erFiGf9R1iJXjMbvWInrdzJLub0,1604
+numba/cuda/tests/cudapy/recursion_usecases.py,sha256=7Wz7i_6VVq5EeZuqkcg1dVfW9DbfC1rp44H7pe4voqI,1781
+numba/cuda/tests/cudapy/test_alignment.py,sha256=dik8i4fG6MPlxVilW4l9pM5o_vBMAsRGItldeE9hvvU,1218
+numba/cuda/tests/cudapy/test_array.py,sha256=bS6rzvp6BKVLFyW8mFRbVoZbxIbc2WCl5SzQ6XG0s8c,10515
+numba/cuda/tests/cudapy/test_array_args.py,sha256=JooZO3bODAMszWwecGT3LpBd3nJxHp7dASG3f7xyVVg,5750
+numba/cuda/tests/cudapy/test_array_methods.py,sha256=shdeSAOKaoZbrvC8hXhETWH8FhyZPTmHg_TMw2DcdUA,969
+numba/cuda/tests/cudapy/test_atomics.py,sha256=IVkvPf0CU2N6NNzPDURk4-JG_3cLU3E0FmRxTVjW0jE,58456
+numba/cuda/tests/cudapy/test_blackscholes.py,sha256=dpPWyCnxRUThaK6npGvN5_fhU-KT1b1GifU5Tj3AHMI,4023
+numba/cuda/tests/cudapy/test_boolean.py,sha256=S8fNBS4gVEZyKk6PpeF5GfG0TLEu_0NvTgybyPNNGLU,547
+numba/cuda/tests/cudapy/test_caching.py,sha256=5o1VcVbir1Lro6yFCerbfbjsxH9xNsYFl7N4Rud6ntw,19082
+numba/cuda/tests/cudapy/test_casting.py,sha256=XrMWIMhGwUGRzh6gocw1Ogj8RORyZZrcFWOuc1ABUtU,8802
+numba/cuda/tests/cudapy/test_cffi.py,sha256=FFbFBA8xJrTfwmlt5LRsRt4xXC93P0aa-bxgzaItwKU,938
+numba/cuda/tests/cudapy/test_compiler.py,sha256=fQ1tLxahLrawlIe1VJlDHciKkrTVutirmOzjp2fEiRo,10821
+numba/cuda/tests/cudapy/test_complex.py,sha256=PO1ySqBsttB9lFnQ1psWDss_JEMbqiHye0c2QBRRVU8,10290
+numba/cuda/tests/cudapy/test_complex_kernel.py,sha256=G08aM81rARqojCKnsunVG7vJB9ggon7H8S8xFaZoK_o,497
+numba/cuda/tests/cudapy/test_const_string.py,sha256=er2ANBSHGby_QxcsZvOKgo9znjKZfcPxKAAT1DoLGhI,4279
+numba/cuda/tests/cudapy/test_constmem.py,sha256=rdnGaRKWqjks3rug1stx5gC0w7Md20_15U8xnj-N3LE,5166
+numba/cuda/tests/cudapy/test_cooperative_groups.py,sha256=ZQuct24GEZnb2JBDvo7ZrUbtTHchysVGoY2BGnSXsfk,5039
+numba/cuda/tests/cudapy/test_cuda_array_interface.py,sha256=73FCQbNaAKpuybAwMOt4eW_dL_K6ZjrRgQw09ojkSbY,15844
+numba/cuda/tests/cudapy/test_cuda_jit_no_types.py,sha256=iqYs48wLh6kR2RwGuuBmuSFUBaOyBdV1BNhxZghJcrM,2126
+numba/cuda/tests/cudapy/test_datetime.py,sha256=2in1Cq8y9zAFoka7H72wF1D0awEd3n7bv56sUPgoNAQ,3508
+numba/cuda/tests/cudapy/test_debug.py,sha256=0H_c9Cm4kNJCem0CkSeL8EQY1IhJ43ho1wDXGEds2Ic,3557
+numba/cuda/tests/cudapy/test_debuginfo.py,sha256=jDPgxSe0G0nAib3wgbfrOg6uvnwmCcuB9GhrzXEvlc0,7875
+numba/cuda/tests/cudapy/test_device_func.py,sha256=aTRyZSOJB3sAShw0YAEgHILrR-TCuowW9KYjtlRErKM,6892
+numba/cuda/tests/cudapy/test_dispatcher.py,sha256=oX-l_L4H8rME1IolwhAyordSGJ152nnuqGAFdWjfgas,26587
+numba/cuda/tests/cudapy/test_enums.py,sha256=0GWiwvZ1FTzSl1FfMxttkWaWrowASfXrSDT8XAR4ZHw,3560
+numba/cuda/tests/cudapy/test_errors.py,sha256=jwHbNb2Ro5pbGOPFetmUhI-vG4s36OKCqMJ-lgWxHMY,2620
+numba/cuda/tests/cudapy/test_exception.py,sha256=Y7VF25tzz2w5MIZjYD3vG1eTfmowFO-RBea2HiJilag,5501
+numba/cuda/tests/cudapy/test_extending.py,sha256=jcu7BXC0wwpnxZd25gbREukjiEMk7YXmIhc-nev5Mvs,4118
+numba/cuda/tests/cudapy/test_fastmath.py,sha256=eZ9KowHlnNByZfUU-8ZB2NhlGBlZhG-5N_sipXhVGgE,8401
+numba/cuda/tests/cudapy/test_forall.py,sha256=rcSiGr_RAqPbc9o4-wrBuH3ucMMlsNdf2ZjjbVUUwvY,1457
+numba/cuda/tests/cudapy/test_freevar.py,sha256=e8KMNFxJYLXcFv2V4OIh7YmI1cwo-NdCaamVmKWnANw,745
+numba/cuda/tests/cudapy/test_frexp_ldexp.py,sha256=82y4vgKIwHTJnA9nqvHOyvLgkdLezqWstge2tChDytI,2024
+numba/cuda/tests/cudapy/test_globals.py,sha256=b_i_JZ6ijBXuxTq5QBqzfCg9c48tOuGhRw1_fc72NBs,1384
+numba/cuda/tests/cudapy/test_gufunc.py,sha256=0NWfQqHmx7tFh6vdS7QtxT86uB9-GmYYfg2ldFlFQLU,15603
+numba/cuda/tests/cudapy/test_gufunc_scalar.py,sha256=Uhe8Q0u42jySrpwAZh8vCf4GMYkiy9NOMolyzEBuri0,5382
+numba/cuda/tests/cudapy/test_gufunc_scheduling.py,sha256=luDtBxFS_5ZbVemXe1Z7gfqMliaU_EAOR4SuLsU5rhw,2677
+numba/cuda/tests/cudapy/test_idiv.py,sha256=HLJ_f2lX8m_NNJjUbl_8zZ0-8GsBlRdBP2CUo_yWb0Y,1056
+numba/cuda/tests/cudapy/test_inspect.py,sha256=lP9-8SbWFn2Xc-qmF6UNhcY6LreKTnveaK5CGW2pu8E,5196
+numba/cuda/tests/cudapy/test_intrinsics.py,sha256=e6lABWy8YBgYheYYGfD75_y8vMbPP71GHb95A4hlLmA,34931
+numba/cuda/tests/cudapy/test_ipc.py,sha256=Ky9d9BnndVgqRFFEcvEX-mn9ai7q1oBpkHykx6ChGM4,10441
+numba/cuda/tests/cudapy/test_iterators.py,sha256=daQW3kSkp7icCmlTn9pCvnaauz60k_eBf4x1UQF-XVY,2344
+numba/cuda/tests/cudapy/test_lang.py,sha256=U1BCVZMjU1AZ4wDSmjsRIPPcAReiq4dB77Cz7GmrdmA,1691
+numba/cuda/tests/cudapy/test_laplace.py,sha256=yD--H5p_NrBHklFNCnxuQ0S8yUIBYScBkvn7hBlZ5ZM,3211
+numba/cuda/tests/cudapy/test_libdevice.py,sha256=4NsZBXweDPQpqfgo6T7eQHaWDVBof1CZDTpI1QTkV74,6545
+numba/cuda/tests/cudapy/test_lineinfo.py,sha256=sKPF5l1cDTyA4UT0IO8Yeq6pYPGt9pIBQtrMAJMJHCM,6855
+numba/cuda/tests/cudapy/test_localmem.py,sha256=uv9UYuytIXQgzHpPgEoWVVVq5-a7-6Io_mWMiNsZ45I,5376
+numba/cuda/tests/cudapy/test_mandel.py,sha256=crVQBw46l4iyAv8_pu7v1eBy9ZJG7OkigB5zsyi6s3A,1085
+numba/cuda/tests/cudapy/test_math.py,sha256=T-KRh9qzwOL3usl_6Cly3FVlvauzGhGnedfAG1hBQy8,27615
+numba/cuda/tests/cudapy/test_matmul.py,sha256=cZpJZ66UFmszLBQ4m1GdPyi27YHFkA6jo29cgQHjozQ,2084
+numba/cuda/tests/cudapy/test_minmax.py,sha256=Lgd9OSELTwOeOI7JwbOf2E15mxv_XkgIrhC0mkoHTvg,2409
+numba/cuda/tests/cudapy/test_montecarlo.py,sha256=jH_LxlcoA8Vb3C3YXg93XQw8J8O8WGCWoLRPg1mmxDg,603
+numba/cuda/tests/cudapy/test_multigpu.py,sha256=4lC9G6LI0MRBDQEkRyTPb019NUFoU9cGrDWV4quomWY,4140
+numba/cuda/tests/cudapy/test_multiprocessing.py,sha256=AjYbSa9nOlv_ycZORifdm7B-b9KdKC1HV-cGLDtrJ-w,1224
+numba/cuda/tests/cudapy/test_multithreads.py,sha256=MfCbyJZu1XsCJOCSw6vvhs4eiP4LZPcF-e9huPmW-ys,2861
+numba/cuda/tests/cudapy/test_nondet.py,sha256=mYMX0R1tmBLRe5ZAwiDVFFuSyMuPav5guuqL3WHWGPY,1378
+numba/cuda/tests/cudapy/test_operator.py,sha256=0nJej4D898_JU-jhlif44fR2yu42keK4GoCLP810l3U,13295
+numba/cuda/tests/cudapy/test_optimization.py,sha256=SvqRsSFgcGxkFDZS-kul5B-mi8GxINTS98uUzAy4dhw,2647
+numba/cuda/tests/cudapy/test_overload.py,sha256=yYgtrf0aER3i6VaPrPpzI_uDa8xjEmdCCDSSAcx91y0,8251
+numba/cuda/tests/cudapy/test_powi.py,sha256=TI82rYRnkSnwv9VN6PMpBnr9JqMJ_F3HhH4cKY6O8tw,3276
+numba/cuda/tests/cudapy/test_print.py,sha256=trOElKENWGwWVcJ3uN4wzqtZiJiQtjLh4vx07iobz9U,3643
+numba/cuda/tests/cudapy/test_py2_div_issue.py,sha256=R88Vfgg3mSAZ0Jy6WT6dJNmkFTsxnVnEmO7XqpqyxuU,986
+numba/cuda/tests/cudapy/test_random.py,sha256=rLw7_8a7BBhD_8GNqMal0l_AbWXzLs_Q0hC6_X8gdjA,3467
+numba/cuda/tests/cudapy/test_record_dtype.py,sha256=grR64kdRlsLcR0K3IxSfI2VKsTrrqxsXuROOpvj-6nw,18769
+numba/cuda/tests/cudapy/test_recursion.py,sha256=8dA2HfAGT6si2OioEx_IkCEgbDhbrjQ94Y7yojPtFjA,3641
+numba/cuda/tests/cudapy/test_reduction.py,sha256=ffut_O9EZAwAwdbEXoYPzy8GkRI6tFKC5XafNdAymgY,2528
+numba/cuda/tests/cudapy/test_retrieve_autoconverted_arrays.py,sha256=LPYAxouZ7JYiu3z4HnNjkGtjYLuIscOxKXiY6RiTv6o,2404
+numba/cuda/tests/cudapy/test_serialize.py,sha256=alE5-lTwbjz3Tv6OvQPSmgtUtu0X9UwFzB2aKs2rYag,2321
+numba/cuda/tests/cudapy/test_slicing.py,sha256=qW2Btdfj9wl5aB6vDFYcrc-BiT3BzzocKiQQ0klqPHY,3156
+numba/cuda/tests/cudapy/test_sm.py,sha256=kh1F0wwQ2_bd54Q4GUX99y2oiWHQwBpyC__ckk-jiTU,14575
+numba/cuda/tests/cudapy/test_sm_creation.py,sha256=bTXDjU94ezo6Bz_lktlPyowTcJHBOWfy7-nJB9e-B_s,7231
+numba/cuda/tests/cudapy/test_sync.py,sha256=Y851UqNkT80U9q_C05SQfvPRCY7jjRARHOMk6g0lU4Y,7837
+numba/cuda/tests/cudapy/test_transpose.py,sha256=JAQX2EUHwlpKCfJDGspaldmsIRbHxnXpsNUrvRrnIEE,3134
+numba/cuda/tests/cudapy/test_ufuncs.py,sha256=-ehvkxelr45aT8sUNL9Hq8cn2GU_K4GL1yWeX-rHqEM,9680
+numba/cuda/tests/cudapy/test_userexc.py,sha256=4ch3Lw8X_w832lU0J5Y5ZLAfxUMUSzbxnWE0bLEWdEg,1470
+numba/cuda/tests/cudapy/test_vector_type.py,sha256=hH3G4XtOTUNr31KyBJVAbbT4053cuJon_PPzoUVlupY,10515
+numba/cuda/tests/cudapy/test_vectorize.py,sha256=iCCiMQERoTnpa2cxU-08bs-AbgGyrQgAC7b9J5nsMUk,9248
+numba/cuda/tests/cudapy/test_vectorize_complex.py,sha256=0cIAvARp4w4Jw38T2qZKg7RD_UZyPVWDOYC0x3AGunE,548
+numba/cuda/tests/cudapy/test_vectorize_decor.py,sha256=rA2Jk1wKbTQXnVvVXeVnhjft8R3zPRWNjVa76M6iI3k,2071
+numba/cuda/tests/cudapy/test_vectorize_device.py,sha256=bsC4rJAvVtoBOaVDBulLC7oY3mDPe7E77z9LUA5mzCk,983
+numba/cuda/tests/cudapy/test_vectorize_scalar_arg.py,sha256=Ivl3RtFjwKJRHAxaFD8Xby5PxjK-mmkxbFXHUHYipNA,937
+numba/cuda/tests/cudapy/test_warning.py,sha256=Bpcj9-pehYW20vn4KY98pADQd5A0gzDUuUk2y48HzyM,4265
+numba/cuda/tests/cudapy/test_warp_ops.py,sha256=OGGXn4beVIjjIB5akR2keyY7gQFaMAxM_AoZNN_I3Bk,9042
+numba/cuda/tests/cudasim/__init__.py,sha256=B1ma2w-Eyk_ooILO3PPxb2K5HMyZY8WZhikDIBATzQQ,154
+numba/cuda/tests/cudasim/support.py,sha256=JjRrfrrLKS0V5p6GX6ibs6QTuFb1NanKfBQSgbLeiHs,114
+numba/cuda/tests/cudasim/test_cudasim_issues.py,sha256=IsjJlxq6LMMDh_1kiO9LefXkOX_Hc1bxeSwXZdB59yU,3179
+numba/cuda/tests/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/cuda/tests/data/cuda_include.cu,sha256=1wj5Of86-kP0hxK5Gr6AhapuyTiiWWJAoFbCuCpyKfA,294
+numba/cuda/tests/data/error.cu,sha256=5m65RDHgh39d0bIW6Dvj0xh9ffhKH1iILeCCR4p2ReI,138
+numba/cuda/tests/data/jitlink.cu,sha256=ne8LLu7RHgbw2lAyJGrVlJHJ08kxUuOLBD9pH-cNxFU,541
+numba/cuda/tests/data/jitlink.ptx,sha256=fBPV1l6krgtGfHasRfaL708M05eNszjAQG33z-NtvUg,896
+numba/cuda/tests/data/warn.cu,sha256=6L-qsXJIxAr_n3hVMAz_EZ5j0skcJAfgzuJfDEISG_I,172
+numba/cuda/tests/doc_examples/__init__.py,sha256=B1ma2w-Eyk_ooILO3PPxb2K5HMyZY8WZhikDIBATzQQ,154
+numba/cuda/tests/doc_examples/ffi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/cuda/tests/doc_examples/ffi/functions.cu,sha256=mRZEyCfZbq4ACTN3sj1236XmTpj1d0IxZ4QTMbI3g_E,877
+numba/cuda/tests/doc_examples/test_cg.py,sha256=9UQAez1jp3vQ0BIfoRCnGJGP17nznNcon-XFR4grqzQ,2905
+numba/cuda/tests/doc_examples/test_cpu_gpu_compat.py,sha256=DRzvoE2iCaISJb2lkshBkJyYBEfdpqZLRXG_N9XRaFk,2305
+numba/cuda/tests/doc_examples/test_ffi.py,sha256=RgZO7xYkJIlSIuJK4k3_APEJAekjkKy5wKOMFdfRoAM,2654
+numba/cuda/tests/doc_examples/test_laplace.py,sha256=UH15R0DbMA4iHLmoZ0GtcttGCNctOUif-u2448JMmRo,5177
+numba/cuda/tests/doc_examples/test_matmul.py,sha256=hS-X_T7x3-BcBanazmnmGxJE_o1A9b9f_VGk0YlJP4o,6135
+numba/cuda/tests/doc_examples/test_montecarlo.py,sha256=_0snszis_UE7LxU5lw9ReNF19Dh5iV0yRy18mUWNd1c,3491
+numba/cuda/tests/doc_examples/test_random.py,sha256=VTgzB55bfjeNQHKg9MINnKa70KNYzxpTOktKwYNYUkc,2192
+numba/cuda/tests/doc_examples/test_reduction.py,sha256=9d40rXxrqvWSkI8r0lMJ42LgU98dVF3Aeon6RAqUIik,2274
+numba/cuda/tests/doc_examples/test_sessionize.py,sha256=kNep6Y7q1WJ9dLeoMYuk9NBKTGLsIJwNiW-um86BOoc,4334
+numba/cuda/tests/doc_examples/test_ufunc.py,sha256=UXwXjL9ybg0OuYOFKnHZk75bMjRMRzrp_xfxAdMR198,1418
+numba/cuda/tests/doc_examples/test_vecadd.py,sha256=0RMJv3iXf9OlAMCF4aIB4Pyp4AnoKUuqC_tY-yNQGbI,2043
+numba/cuda/tests/nocuda/__init__.py,sha256=KeAvH3QOb-KXXkFtzwvYkQp2ZrQmzgfKDkBCVIOKXXE,257
+numba/cuda/tests/nocuda/test_dummyarray.py,sha256=hpdNlYhZLKrrN3TF4i65djpOlcPpEkTG1MX8385Qov0,13567
+numba/cuda/tests/nocuda/test_function_resolution.py,sha256=o4DYocyHK7KVPil6LQI2jzZ2xSWop8bLZYGtV067CSs,1425
+numba/cuda/tests/nocuda/test_import.py,sha256=teiL8rpFGQOh41kyBSSNHHFYAJYgpdStXkTcpK4_fxo,1641
+numba/cuda/tests/nocuda/test_library_lookup.py,sha256=7kJOPHEcrjy_kTA9Ym-iT_B972bgFRu3UkRtwIgWtuI,7948
+numba/cuda/tests/nocuda/test_nvvm.py,sha256=n0_-xFaw6QqiZbhe55oy7lnEeOwqTvA55p5EUFiTpNw,2006
+numba/cuda/types.py,sha256=WVfjcly_VUpG9FfKueiEPzZm2NV8Hg0XAFg3bNzPdVc,1314
+numba/cuda/ufuncs.py,sha256=4ZhGEF9VXN4o61h7kbly6DdiQeDADGet9L13fipK4QQ,23325
+numba/cuda/vector_types.py,sha256=s18dY0IUpT-RcaBvQsa_zEbYuuL2IT0Vh6afCeccwmQ,6750
+numba/cuda/vectorizers.py,sha256=u_0EzaD5tqVH8uOz4Gmqn3FgPC1rckwDAQuROm0BXm8,8915
+numba/experimental/__init__.py,sha256=RBZ2sMQEP7NKSKqucS8ij-dOOZrmHiWM_qVLVP1pPe0,30
+numba/experimental/function_type.py,sha256=KH0BteKy-Oo8hpGutWX1ujbD7Nz9ILp3Bw9cI96vt7k,12475
+numba/experimental/jitclass/__init__.py,sha256=3Emu3qLxfO6zhqsLfzRu12vATnGwqLYERSV_jRW9g9k,219
+numba/experimental/jitclass/_box.cpython-311-x86_64-linux-gnu.so,sha256=ty2CBPpjp4PnwT5bibwvF_Qx15Bs0LlY6iiLtrfcLbk,31440
+numba/experimental/jitclass/base.py,sha256=hBZsyLuCphoM8NCyYSVXy0hxYRGU1LHt1rBHQe9G6mg,21359
+numba/experimental/jitclass/boxing.py,sha256=CTJzaHvBBFiinKJp2HZsKT0FWJ8Qf5LaU_ddP0dpCwc,8296
+numba/experimental/jitclass/decorators.py,sha256=y_Y-ugNa6jnmIX1fhLpadlu702857iRUb2tYhS3Ke3w,2404
+numba/experimental/jitclass/overloads.py,sha256=7WDafDbobDXd96BdHovNvWf_CwZQ5CEbPA29efPGw38,7316
+numba/experimental/structref.py,sha256=suhR0qtsIFLn8i_4fzxK6JXDrx6UYCUMRiH8BPuYv44,12075
+numba/extending.py,sha256=dkGJPNMggy7xd1NRV1ws6teIK7Ze2lTFvpAz7Cw5drI,133
+numba/mathnames.h,sha256=pNbqCU38izsPBn6EaZDfT_HURKIaEkmpm2STVyFtaEs,1774
+numba/misc/POST.py,sha256=JrY0ygk5v272TXHpqQNnDKIX2FJK04pDAkmdtAVaWEc,811
+numba/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/misc/appdirs.py,sha256=zyXqBFfj1ERckcERX_G9d3AAGciKuB06Aj5_mnyGrTQ,22388
+numba/misc/cffiimpl.py,sha256=5ubOeU-F0MNi2aQ5Y44AxcYvegLjPW-w3Zs8hfPhW-g,615
+numba/misc/cmdlang.gdb,sha256=hX5t_27IhOlfgGAwV3aVPyZ8v1m7hedd6myQbE8mMB8,101
+numba/misc/coverage_support.py,sha256=ARjlTO6wBlitMKrdojbj5inX0nozPlskiubxJ-eQKZw,6236
+numba/misc/dump_style.py,sha256=TTQm7BmBzLT9VRuWRjpYkGqg_lXwtoAvEbcK5wIC-XQ,2265
+numba/misc/findlib.py,sha256=r7bP2GeCTXsGHa5bWKNKsVCvqDrarMlvORqWmJoeOHg,1848
+numba/misc/firstlinefinder.py,sha256=1pTWZIV54RlZu4BGuGAoyx7Z9Qq83cIBJ-qv4ETEmKk,3253
+numba/misc/gdb_hook.py,sha256=qX-ZHzj3Id1eGW5eQpXALeGZD8Cj2cZyfCqdoixd8K4,8567
+numba/misc/gdb_print_extension.py,sha256=RcKxCFhzbwr7TrZsX6DZGjJkEaNzoZn19W9vCktG4-o,7728
+numba/misc/help/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/misc/help/inspector.py,sha256=9tgx8tKuYEffMWTjnayD7NJbwaxcu7q7aDYKSh6AdFU,12903
+numba/misc/init_utils.py,sha256=2vEcU37csAn4Ogoi6eyCEyNiUnEf4P-9PLcFvkk6xRI,1242
+numba/misc/inspection.py,sha256=SSHPt4V-CphtwEIEbOFhjYURe1hHvX8a_FDpMyq-P7A,4499
+numba/misc/literal.py,sha256=AQnd2XF5fJYnR8BuOCRcoCt97-U3APuEGViyZTie3VQ,705
+numba/misc/llvm_pass_timings.py,sha256=IRArf2xGeIYG6Q1ffIuL84RIIeN22oTFwAmuoPiV25k,13362
+numba/misc/memoryutils.py,sha256=V9t7kXxYPuyG_siD2CTfqqvB2naRxtK59S1m0oAW9pc,5930
+numba/misc/mergesort.py,sha256=H4XyN8Lmw4NBZ3m_UEltHK7T5ZADc3fbok2KwOKATm8,3548
+numba/misc/numba_entry.py,sha256=OTSqI4hYcr91ZXyNmbJmbQG6hMEQgTGZ-no6McXz4o4,2618
+numba/misc/numba_gdbinfo.py,sha256=Dunek2AGTgxNZFQnlsEFHzjc0806J8Abz2eTTj0TZEI,5962
+numba/misc/numba_sysinfo.py,sha256=T4HAI5A-Fg895zPYK40RVWf2M8OxrK9aKMXHzkDye04,27299
+numba/misc/quicksort.py,sha256=qqxWmkcu5bez0x7jzYeqGMGnOS-56zEi7XDFYw0BtFc,7647
+numba/misc/special.py,sha256=eEIAB_07X8EO7BkrQVz2Z374kjHLIXe75JFnx2j0uqs,3320
+numba/misc/timsort.py,sha256=tSAqreRk39eRy7FD6GRCGLIpUhG-BgVygXphkxtcJiw,33503
+numba/mviewbuf.c,sha256=iotlLmyPwyGVpAje19FbADsot8B3C9Q0UEZBItkUWiE,11950
+numba/mviewbuf.cpython-311-x86_64-linux-gnu.so,sha256=OrDX4MUjzPy6Mc3tLGc_3TLojjsu5rEqFLrJFVx1p0Q,43704
+numba/np/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/np/arraymath.py,sha256=VKC2Nk-vORLxEE_3ZONh8Kwen_dtn_exLJnalL0QqJ8,158266
+numba/np/arrayobj.py,sha256=-oqcaExA2wtdrcsy3KT8NieHBylFA7ZphUK9iUkCWN0,270005
+numba/np/extensions.py,sha256=YEN2b5udrIy4uhHrp7Os6FEW_h4lv-dp4aRB2Z8Irhg,96
+numba/np/linalg.py,sha256=LDqgdAcLosNDG8NCLBOFU9giFjZJo3-oyFmf99M3nUM,91872
+numba/np/math/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/np/math/cmathimpl.py,sha256=RZwO6pYJjgX7d4kTmymDgXIECfJzZ_oW8xG-nmDo5xY,17628
+numba/np/math/mathimpl.py,sha256=aSqVdtQ91NRk6GZ_wiRtOpiXwsu4S4EEtaEcs6dJ0Yw,15556
+numba/np/math/numbers.py,sha256=XrzM_xxyKkidhRYDRAdXrV0yaRT7dY208NbXx5_uLks,50276
+numba/np/npdatetime.py,sha256=PVVbhaWWi8TbacrwqgLln5-qxdoN_ngONIk6Nq9VBRI,34541
+numba/np/npdatetime_helpers.py,sha256=JPUTOYJ9Eg-3H4K3oLp2q0lLXKZcML3fBpG7WwJ3l8g,6649
+numba/np/npyfuncs.py,sha256=POdhp5joCsHUA7_8yeMs0AHPjHkqqnR2UvVcP0rmZhI,63021
+numba/np/npyimpl.py,sha256=4Y_uMWxp9d77QjWOokRO5LI2XNWI-lfSkh4wBjlBG2Q,36870
+numba/np/numpy_support.py,sha256=2IZYGQ4sR4UqnPxNtOMw7KHlf0N2ro1GdHsuUffo3r4,26900
+numba/np/polynomial/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/np/polynomial/polynomial_core.py,sha256=t_4zkvCCjPQis9q9oq-6ja-eaafnE2eIbUJBRNGU8kw,9003
+numba/np/polynomial/polynomial_functions.py,sha256=jH4uH46RBg2NJ6t_sAUwEwvrHcVrLxMdln_xsJLr-P8,10765
+numba/np/random/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/np/random/_constants.py,sha256=lbWbj6z1gzNQMZV-BUIcmLeYlzTl-YytJUeorQtaU-c,72630
+numba/np/random/distributions.py,sha256=MxdSHYVvaoAFWgSJeMma-AHazvqfLJmuCcHvx2CnsnA,20906
+numba/np/random/generator_core.py,sha256=BdY061VuV20S0ppJGYSR-s-L13UhJEdvtKxbIRKLFeE,4158
+numba/np/random/generator_methods.py,sha256=MsZifo13zLPcipABAdlabQxQQUdNS2OySkZJmEzhNWE,34316
+numba/np/random/random_methods.py,sha256=H18TXrqkFTqnLOrAHo_y-KUcM_iETWHDpczdLEs0_e0,10210
+numba/np/types/__init__.py,sha256=TtFvAXPp2KZFsXnYqdcfZnIWztil_3qbXrqv4nww1ok,46
+numba/np/types/datetime.py,sha256=Kx9Cuq_4z1XOK7oyKbCuib4JDC5hlpkjbSoiLnmYhp4,11068
+numba/np/types/datetime_registry.py,sha256=PyA6YM5SfKnYhux2PAW_WzQGIauy8_a5VkwBbuxmtWs,2536
+numba/np/ufunc/__init__.py,sha256=TUc7_N8172fYX5n0ZxnUn-LEbaL88rZBHmqPu_OdCdU,1070
+numba/np/ufunc/_internal.cpython-311-x86_64-linux-gnu.so,sha256=8eU9oAhh25gexW1KbydEuJY9Wf_SJ4nvgyFSbmJfM3Q,92584
+numba/np/ufunc/_num_threads.cpython-311-x86_64-linux-gnu.so,sha256=OD55FMptWDG2bfTKmauHcrHo7ne5iIGgwp0O7sl7X-o,26408
+numba/np/ufunc/array_exprs.py,sha256=pJbWr9S8zCpkZPXFRJIpnjf-FKe3QfYeTB6vyZIyTrg,16878
+numba/np/ufunc/decorators.py,sha256=_J7b_05KDBPBnyFvEcL-ys5WGSkUPfml0oIdCAnC-IA,6107
+numba/np/ufunc/dufunc.py,sha256=8CnYG-CC0Yyq-a727Dq6Nx2aD3rx_nulDFiUfL0sC8A,40648
+numba/np/ufunc/dufunc.pyi,sha256=fi4sgFFDaYtPn6votyj4_JxrYief04KehtFTcD9UIGw,4213
+numba/np/ufunc/gufunc.py,sha256=lqtm8KbVNisO93gvuBXGOrsXpF2mxq0zf5dIG9rOf4Y,12794
+numba/np/ufunc/gufunc.pyi,sha256=zlgZXtYVqRvaf-WIGXkDWCRkk8TNwotXbjHhdE0hj-8,3476
+numba/np/ufunc/omppool.cpython-311-x86_64-linux-gnu.so,sha256=WXMQ1TlHheQ6nzc4dYy7Z-CMNQ6XShh86taRHw2qsRU,600089
+numba/np/ufunc/parallel.py,sha256=gBZrwbkbjrOb4UeiIWoS6hkTBBLXhBdbmnyweOCynUM,26279
+numba/np/ufunc/sigparse.py,sha256=r9068xH89U-U-sU9nL4e8JGhAuMGQv8op8ucremc8AA,1846
+numba/np/ufunc/tbbpool.cpython-311-x86_64-linux-gnu.so,sha256=BgZDuTyyvKet3GDga24pMZWjBNeMEDPZLtdFL8h-ym0,1054537
+numba/np/ufunc/ufunc_base.py,sha256=LhdG5z2lvspsCIadAP7IS8h706uzWjQBuyNtJcyY4Nw,3335
+numba/np/ufunc/ufunc_base.pyi,sha256=QMDYTxe8FZSPz0DToKVGyQ1U-zj_aUkWBEcFX_lVbdE,5009
+numba/np/ufunc/ufuncbuilder.py,sha256=BxGF-sR6K-pSk5J14AzjYHvz22HrHWn_rfaKQS2AIn0,14610
+numba/np/ufunc/workqueue.cpython-311-x86_64-linux-gnu.so,sha256=ibcgZOdOVU7SS1sNiwZoB-iwxk5PBncMdA01WfhITFY,604632
+numba/np/ufunc/wrappers.py,sha256=CdWTlT1USqb-tw_3tAj_CRC0VWv4tIyeDJr3n2Cq6DQ,27203
+numba/np/ufunc_db.py,sha256=OTgMbz79rRzmRkZZ7US5-bcZ5NxZ3dKoiv9msxGUs8c,42510
+numba/np/unsafe/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/np/unsafe/ndarray.py,sha256=dzc0UlE86z_idhAN73eDs9A21rF4v6BkOpmEHbFYlsU,2704
+numba/parfors/__init__.py,sha256=YXMWaFldoQqHT12hNUQyS7nd7Zg85htjssj1UopkA-o,42
+numba/parfors/array_analysis.py,sha256=4k6K-fDMVFEhqEw0R71gbHoNhBsG00J6RReUjCm5JIg,124117
+numba/parfors/ir_utils.py,sha256=zR5sDinvARVsMcmTPgJMW-vcCG8jD5p5ZKBvHYa-YDo,5446
+numba/parfors/parfor.py,sha256=dlCYJAzXdJGDTsT0_1K1tVZCepGoRlEpGkUHME9Q9N8,228208
+numba/parfors/parfor_lowering.py,sha256=0RmFmxl5uN7Lx76wrFNJ2Qyt41suWT3Hqef063sixoE,87652
+numba/parfors/parfor_lowering_utils.py,sha256=e2ZuU0MX2PGL_bKg_DOXsVzl0kcqjdrqh5A2AKJIO1U,5638
+numba/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/pycc/__init__.py,sha256=TzLOywD1B2CPTXQ1c_mzyPOSQTY5C3-JR_VfNZMG4ts,1220
+numba/pycc/cc.py,sha256=xZnsrVcSa9My6R6zZEuTU0KdXknD32AJ67M2Qt-ckhE,10626
+numba/pycc/compiler.py,sha256=tPlNRKcVViCAs_6vBR-GmxkVuioCxPH1tbbEPL3-Dxo,19458
+numba/pycc/decorators.py,sha256=n4WakJj9iRYkdrRFoLLohE4ibhuNhy6TDQ8I3LMwvuM,1884
+numba/pycc/llvm_types.py,sha256=n0obSYyFc7h356LmVqGhwFMKH4NpXIXF5BxztoU240o,1239
+numba/pycc/modulemixin.c,sha256=dxTyYa9IgaANDRM4V7i0qcaRR-wdN6yM6Y6qhcZafQQ,5984
+numba/pycc/platform.py,sha256=b-FBpRGkI7qaZ2WdHZ1qs10NnXfkyitMp3Sq0onKI5o,7431
+numba/pythoncapi_compat.h,sha256=wB8PCPCqYqpYR3YIdArroyYJ3WsEc5GhG1xKAp0DSZo,45414
+numba/runtests.py,sha256=xv1W8XbzPewB_X32KXFugsmwt3lZL7lfKfryaC7N7KY,237
+numba/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/scripts/generate_lower_listing.py,sha256=WCaoIzn_LmFHS-pYTW6vdKufcnXl1e41-_XsV1mxnm8,5165
+numba/stencils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/stencils/stencil.py,sha256=FTJs2phQeT91x0mxMU4DGbdFKkIEWAlTPCgHQbxik4g,39893
+numba/stencils/stencilparfor.py,sha256=Ar6Ge9UT25ybCsMnE8R40vDpHufK8zhzKVRW3YwA2vA,44974
+numba/testing/__init__.py,sha256=QL904urGyqVF5OOfyq1uLnAn-uhgRcbboaQlj2obaMU,1976
+numba/testing/__main__.py,sha256=MJrAbExox9UHv1UnMDx0f6JG_oA43cvhzHQoTOSl7IY,106
+numba/testing/_runtests.py,sha256=V7XJTU_iTftXIu3Rv8FqQd_ECjCXG6B4vDdujOizMfI,3727
+numba/testing/loader.py,sha256=pQdHO6VLZo0Lzbju4g0dptXGc64IJlbguzym0w006fM,1113
+numba/testing/main.py,sha256=f65R_FQPBHTBOdLrficGN76ZVrwZ_xE196pkQbNDLPA,31576
+numba/testing/notebook.py,sha256=zuBfj8QHXFkNvV2oyz23gjFZe1Ixt7OFAMtgjCSqm-Y,5501
+numba/tests/__init__.py,sha256=h3tyMOp0uUiirVDAOEY3Cymim51mHA77xTpwATXeu0w,829
+numba/tests/annotation_usecases.py,sha256=0O7hw4-dVfAQ2mUoSLbjWYakSNzcv6B6nyBJCRPajdo,316
+numba/tests/cache_usecases.py,sha256=bFw9cZVyvN9GQTdg_Ci4U0wF_8DLAKBwf5tXh95kTQQ,3566
+numba/tests/cffi_usecases.py,sha256=xGpQl4X7akIxuqMOjx6mxt9tXVbIhVhHe0B6nmaF9tM,4927
+numba/tests/cfunc_cache_usecases.py,sha256=XqWmWzZZy2Oztz3iTiig1TsJ6fpZaZyB6B99ThHZYKM,1608
+numba/tests/chained_assign_usecases.py,sha256=KjBf_w7zeb-OPAYsNzJImekuRzLyj0EcMqJ8TZys9rU,1045
+numba/tests/cloudpickle_main_class.py,sha256=GzSO01WRCCrXYlp8HShxryKJTwUvcAImg9F68WuLnc0,155
+numba/tests/compile_with_pycc.py,sha256=u69eNm_xG3DfmWO1FVaGIAdOdtBAxXZ_Dn1gpTOfsnM,3282
+numba/tests/complex_usecases.py,sha256=xlbm0rUg5prZV4qIUsekCRFjJCpIGBhLpgABnefor2U,1515
+numba/tests/ctypes_usecases.py,sha256=lOXJpgWXqBG0AJ7IguSW-zuyA6iovRqIH67drTQj4Gg,2425
+numba/tests/doc_examples/__init__.py,sha256=AQs2XphXAaU5K8g8XL27zyLP1L3VOYH1AP1aCg1uf48,267
+numba/tests/doc_examples/test_examples.py,sha256=vGS3EIVT2p4LzK5MVbQrLhN4AzGFkR0UH0h8Ro3PsJA,23610
+numba/tests/doc_examples/test_interval_example.py,sha256=FhXF9YCYOiWilLYzjlEzI1NB_aDcebTb84_8IBAGZ1w,8867
+numba/tests/doc_examples/test_jitclass.py,sha256=hEKPXpD_3JmNAGPC3fhz6GHxofYRtM8ZwM2ZLJEigSA,3057
+numba/tests/doc_examples/test_literal_container_usage.py,sha256=BKapYbcT80Kwe_QYDVTb89sGIi-hQ-r0x0q8mwlqfUQ,5762
+numba/tests/doc_examples/test_literally_usage.py,sha256=9LK3Tw3gW1bhpqOd2IlscVXf4q0S7esdo2fcC6Kb9eQ,1878
+numba/tests/doc_examples/test_llvm_pass_timings.py,sha256=aolHZB8rDoUUGlYzmWhcmJR9Y9mU9d5mRNZ6SBCVFGk,953
+numba/tests/doc_examples/test_numpy_generators.py,sha256=CDWKZS7CpJy5Z_inqu6LLPDVpnhWouIWhk7w4-M1wMM,1099
+numba/tests/doc_examples/test_parallel_chunksize.py,sha256=pKI38Udgb58Uaf37vsVASo6WEr8l10I4bI0AM_0ZwRs,4176
+numba/tests/doc_examples/test_rec_array.py,sha256=fhCOCXYunEcO2D2ieOs6W2Iqe28vCDfi8avyuBuSF2M,1313
+numba/tests/doc_examples/test_structref_usage.py,sha256=hbBFmHR2s6oD3KK4yqF5Bn17iIoGzIObQ1Q7jiJ6iYQ,4852
+numba/tests/doc_examples/test_typed_dict_usage.py,sha256=XCrsqc6dZUX2-90UZwniAVL5Qqj-_dkqCS6IVX6Rdk0,4051
+numba/tests/doc_examples/test_typed_list_usage.py,sha256=x9XKxjziN8dMxPsjMzvQwvAI0hT7_cuUvVM_JLgn76M,2941
+numba/tests/doc_examples/test_typed_set_usage.py,sha256=4eQJcZQt_5afKtl8HjkjEYc6NF3QhD6g60UbUyA4QWI,1352
+numba/tests/doctest_usecase.py,sha256=i7DEqCXsEPt3XxRAk6tzMTJnHbdAJGpxPwCCXTuInjQ,484
+numba/tests/dummy_module.py,sha256=HnzviWYvQx54SYXKY--jg7JgDDNVwSyawn1yWkyISUM,57
+numba/tests/enum_usecases.py,sha256=rGVSwqi8zpbjsLoPdUO-vooLjL8PbNdOZcvG7ey_pZs,1018
+numba/tests/error_usecases.py,sha256=Bf8ZmO68Vw3T2KU0pzxlmx1L8OoqYMK2IJxNsnXxcWQ,79
+numba/tests/errorhandling_usecases.py,sha256=Ds-kMSAGf6SywK1xTyMPoXl1vwlDtIRtmchnAwluHDo,284
+numba/tests/gdb/__init__.py,sha256=AQs2XphXAaU5K8g8XL27zyLP1L3VOYH1AP1aCg1uf48,267
+numba/tests/gdb/test_array_arg.py,sha256=VlK8wthLszkVlo6WorHxfFO-skKhHteavYOagHedCCE,1723
+numba/tests/gdb/test_basic.py,sha256=ttVJkT_1ZbTdAkRCN1mHq4jHt6rL_Q60At9FUfLMinQ,1162
+numba/tests/gdb/test_break_on_symbol.py,sha256=ArsXuGi-1Zw2cLQ0TH3pQlHH-tpvEsj9FEhNBJ8WD7Y,976
+numba/tests/gdb/test_break_on_symbol_version.py,sha256=uSK3IvYXac0RMqpqD-IAsUEzHx1Z0livBTKZjxH_dCQ,1940
+numba/tests/gdb/test_conditional_breakpoint.py,sha256=hvzxre17KzBE9bN-NcNLg3Eg37MYk2XUgGhmDfIRD9w,1224
+numba/tests/gdb/test_pretty_print.py,sha256=cb4bPcYpoOr_2n9CHHxiDTzpsx1I0ZB1f9CeT3oEi74,2416
+numba/tests/gdb_support.py,sha256=geLjuf9hcrZonEuhKz3YkJo4s5Kui7O0lEj1q7HjpCc,7439
+numba/tests/inlining_usecases.py,sha256=oC8Y29RUNdqSR0nWmEZ3JC0JeaRXCbP3wE45TauiiH4,1019
+numba/tests/matmul_usecase.py,sha256=97UclzEySdrOuvhWLcWSvpqro5WXRMGgomZIA6M3Qdc,552
+numba/tests/npyufunc/__init__.py,sha256=AQs2XphXAaU5K8g8XL27zyLP1L3VOYH1AP1aCg1uf48,267
+numba/tests/npyufunc/cache_usecases.py,sha256=-XasSXNW7ewG8-HLpDj8yZThQOg38455UtWDuMfDGaE,1488
+numba/tests/npyufunc/test_caching.py,sha256=ZFL7l3K4ma3RIOHfZTScN30NfUNhk0FeykIMKfOIScE,8569
+numba/tests/npyufunc/test_dufunc.py,sha256=RTfcbii7yki85orvcLuRRGgC4q4po6dN8-rfkmPSVqI,42112
+numba/tests/npyufunc/test_errors.py,sha256=zaR-AvH0tF2Ep1yFxR75cJkfcApmWBMFHRST_qD8o04,5497
+numba/tests/npyufunc/test_gufunc.py,sha256=uFgE5JeeB_I-X6y7wxfG8xjHAn_yzQa-wJAfESyQFsM,29309
+numba/tests/npyufunc/test_parallel_env_variable.py,sha256=NMlVyeMdSoFV3oBXxoR8VHeayPGDLMaNrgGG588MpBA,1264
+numba/tests/npyufunc/test_parallel_low_work.py,sha256=BPeAxpfoZu9H2S880AeVAtWlIKO9FM9DryWG6niFeYY,1056
+numba/tests/npyufunc/test_parallel_ufunc_issues.py,sha256=al2DaPWlIKXl8pI5SNJaBR7qIGnDuPAPnGsGMxUbF4g,4387
+numba/tests/npyufunc/test_ufunc.py,sha256=oaiPMmJubzPAYDNNhu3fDwkSaGK6Atyhs8HO2qN0Cjs,5219
+numba/tests/npyufunc/test_ufuncbuilding.py,sha256=B3BkVrm9svA58wXiJey-FUXD1Z8HBkNd9wf9stGxeqs,16809
+numba/tests/npyufunc/test_update_inplace.py,sha256=sr748I5uqoaWhW1YNrG4j2ScagmUM1Lrq7NWZgTuj4o,5078
+numba/tests/npyufunc/test_vectorize_decor.py,sha256=Z7NS7QmTt0CmCZbOsI-e4K_ujz6EmgvAIdqn1mZ4eAk,4504
+numba/tests/npyufunc/ufuncbuilding_usecases.py,sha256=CM-gB-XcZqb-CKUqhEt0NiK-9slc_yUstDlYyzibaqw,1061
+numba/tests/orphaned_semaphore_usecase.py,sha256=Lwc2zeGSfc3In51ROGkwGE7fyLeZoIwfz9_1vb5yC9Y,592
+numba/tests/overload_usecases.py,sha256=ySd2qYfd7CYCnzbG5NJHyEvtZCTCFySM6fixrQrbWR0,582
+numba/tests/parfor_iss9490_usecase.py,sha256=aNDICFHJvtXpKEMYcI9STPuCYuVLm7lP-OY4s75P4kM,2640
+numba/tests/parfors_cache_usecases.py,sha256=rj-UN7QzYamC-xAYEVRihggNCyTFEpFK0ZzktUqVxxc,1778
+numba/tests/pdlike_usecase.py,sha256=eDi-ks_pldk6qbYMRsLTDFhnCe7-fRA3g41PJGPpYNU,8780
+numba/tests/pycc_distutils_usecase/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/tests/pycc_distutils_usecase/nested/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba/tests/pycc_distutils_usecase/nested/source_module.py,sha256=SXWOoaRIkoBpDt-8Djmy5Tj7aOUCQ-DMAFgMnrgB5wI,328
+numba/tests/pycc_distutils_usecase/setup_distutils.py,sha256=uO6Qiv98Wqw_DUSup-GvyNsTVD2u-N6YOgijFIzEuZQ,207
+numba/tests/pycc_distutils_usecase/setup_distutils_nested.py,sha256=d-HOlctJ8Mz0iF1eGfVfPgf5PC9YQtBx4SIi5BVVyj8,215
+numba/tests/pycc_distutils_usecase/setup_setuptools.py,sha256=19kQpIjGjT-0AcYfONCTHb33JyC7lkv-IrVBSYkWkA8,173
+numba/tests/pycc_distutils_usecase/setup_setuptools_nested.py,sha256=zWLMLRjwyBO3p-51165Qpw29fUlc4hvLWi_wBPFoIXU,180
+numba/tests/pycc_distutils_usecase/source_module.py,sha256=XdiOyXf33sIsFquozugu4-qVkNK8uDyap2M6cR3FhzM,326
+numba/tests/recursion_usecases.py,sha256=NIkXj_bUe2MUjK5lSlDAszG7Th3llrLWtdOv3c1AMrU,4133
+numba/tests/serialize_usecases.py,sha256=RfKx44jFPUvfEjaumYOj3XKHeOcBKCaP6hIkV-t1gqM,1982
+numba/tests/support.py,sha256=-2YBSv6_OIOyEFyo_HXFrwLRgMwRgmbWtT02vXvhM_Y,46877
+numba/tests/test_alignment.py,sha256=y0vaLiqkDWaUwL10r3o3yx65OgpHVQ9FbFITSvhgC1k,1086
+numba/tests/test_analysis.py,sha256=DDaebrUZ9IVS259ffD0a0cahcFBix7OiSKZCG_th7h8,37230
+numba/tests/test_annotations.py,sha256=LATeDSyu9gYwo-3jYnVDSKerPEPu_RSoe9X6NbnhyQ8,7540
+numba/tests/test_api.py,sha256=kAPv2qeCKuCmYnnYIcNmhbUU_Q00EczpTN1lqoLP-lo,2614
+numba/tests/test_array_analysis.py,sha256=PXM-yIR9eKYuHluywQ9-zqTfQoBoFDmAXcczCJicNc0,42608
+numba/tests/test_array_attr.py,sha256=2IU2RrTn95804oOMlZpDYs-W66uPOIZj3XXIgZSyy9U,11675
+numba/tests/test_array_constants.py,sha256=QYL1Zz-sSYuvGxKUYnCSi65i-9CunsOiiiC_jxUNoS8,4826
+numba/tests/test_array_exprs.py,sha256=ZJ8Pc4Y_1IAxu2tY78w-NQb1ql3TJxCSoF0thKTw318,24229
+numba/tests/test_array_iterators.py,sha256=VXErTR-oSOrTaUEjMFvb0uOhLuOggbAC8Ftyj47AZjs,17894
+numba/tests/test_array_manipulation.py,sha256=s9NrClPyvxuPsPf3O9VjpDIliWMU-YjIIewJXcA78v4,54748
+numba/tests/test_array_methods.py,sha256=8zB3Qmsx2pQnpLHQTsDvfj67_4mrbe_os_bv9tLJs5c,70756
+numba/tests/test_array_reductions.py,sha256=3cZkfx41K5HhOXCaT0tGSbQ5uf29v3IIOqroB2bu2dU,48551
+numba/tests/test_array_return.py,sha256=xPqpMaVkFYUlV4zfr7gINoJD6UDRMf3eFJ4wvjkZkV8,856
+numba/tests/test_asnumbatype.py,sha256=L3OQHjx5MBNXC4y-zIlWuRNvPIedgmWaKot9nBmW87c,13033
+numba/tests/test_auto_constants.py,sha256=IEjzoT8_H88ferTGYz93Sszb8uUSi0hr8SOxwW7Oklw,688
+numba/tests/test_blackscholes.py,sha256=7-eHw17Vhrd_tn9RXhQA_5aw6dVxURI-6VkW6TaMebs,3599
+numba/tests/test_boundscheck.py,sha256=rX_OPNrDOef2IEz_GLD6pS7YJYzLjBHSUaQfgu5EkOs,8113
+numba/tests/test_buffer_protocol.py,sha256=dZ8W-fkn0A3I41CbQu91mvScgU7SLvxfYjDX29EyIjE,8810
+numba/tests/test_builtins.py,sha256=AXyizlG7NDbMehMywyWmS8ciR9p7XGjlzJks0gW3tMA,52943
+numba/tests/test_byteflow.py,sha256=fSiY82ci3R4OsxIthMlTqt1Y42O-Pn7rBa5nHaojqBY,2426
+numba/tests/test_caching.py,sha256=mgOflKwkg4XMpZOYXV4dfKUCjhzhcOgepjYJxVl97rw,45170
+numba/tests/test_casting.py,sha256=KcHdtGTQgBXgMr5Yi6ghpw-4AW3io-inYTPv0mas2xs,3913
+numba/tests/test_cffi.py,sha256=lnFqpoWcsoAz5EibxKym9TtbWYFXBYCWKd75qagQczQ,6695
+numba/tests/test_cfunc.py,sha256=YIxEkOhtmse0d7nNzhB5NKA0vXd36oE90n260mcD1pE,13079
+numba/tests/test_cgutils.py,sha256=CwjjiiRlPsuFKN6gybHAcGeRrSIYsx1_8vUZO26NA1Q,4863
+numba/tests/test_chained_assign.py,sha256=Qy0fLfmKP10z24BTTyf8NSRIBaUp9Y9Cl8HRKtaLWTA,2480
+numba/tests/test_chrome_trace.py,sha256=yBVKUJdic4GrutGM5e09lDHy1KyG-xjN6gqfAKsrIhM,1432
+numba/tests/test_cli.py,sha256=ryU8WuXwMeKn792ephhhIPl5xolbOvDplFwz_8Qxg7E,10413
+numba/tests/test_closure.py,sha256=GF7F90PzJiOZyxONKf1rxaLMP8nQwt6I03lBOFUsi94,13629
+numba/tests/test_codegen.py,sha256=LsfZNz31W4nT811cHrtvgqhVmPTg9rBioYnBeBAQN5s,9048
+numba/tests/test_compile_cache.py,sha256=_nvI7rUTKsCPQWoiEln45I1fy2zYAB7cH_ioGDDgMG4,6456
+numba/tests/test_compiler_flags.py,sha256=DKZkORlXLVM9qWL6mT7M5NL9a6_D8tKVn_eXJgGasME,3554
+numba/tests/test_compiler_lock.py,sha256=lojUn2JRt9uINgVJobHwFfNOvJiKaGTWvjuNZ8_xyIg,511
+numba/tests/test_complex.py,sha256=l6p0K9jaDXUx7m2NxcO1nINmUtgyWnuHxcUjk6qjp_E,11378
+numba/tests/test_comprehension.py,sha256=A9Tf_Nfcl7fJofV2-Sky4l2ZdL6QYH2AvHXoIULYLpE,17716
+numba/tests/test_conditions_as_predicates.py,sha256=EC925MaOIm_6fVmn4YtvlwwOCX0i_4T-kI6I0Oql9wY,5275
+numba/tests/test_config.py,sha256=DkRUifyGOL7Pawt99wsb_hxiZQZXZkA3ZbJNl7D9Z3o,7934
+numba/tests/test_controlflow.py,sha256=6hQ7VdKwX2RgXfJLxA5VNaN2_uEd1NY3xc9XXwYCJzk,5098
+numba/tests/test_conversion.py,sha256=AYC5UL9SjzPl1sS89Tj9kPMZBiZMMvIVtfo7GAome4I,6900
+numba/tests/test_copy_propagate.py,sha256=-IY8udIT0z9LKBKgjs0f-799OLsuhfXptJ1x4TFtNbI,5658
+numba/tests/test_ctypes.py,sha256=OYEIJ75kdAUrE5sYNDSiF26t8jRazbELiscDu1_LBJY,7431
+numba/tests/test_dataflow.py,sha256=P77UdUTt6_pZiUsG6Kn-VyIPlixcAvDoqbpK0gYQylY,4848
+numba/tests/test_datamodel.py,sha256=sRe5QyCVkX7y-p105AGpK45C84YGJFMt5R9lvuq_B6I,7014
+numba/tests/test_debug.py,sha256=VW67kUy6XaVWXJS6GlJDXOurgkf2wHYt9TO7mFujsmM,12092
+numba/tests/test_debuginfo.py,sha256=618wSAVv6HyTmsCpnB6lUqG7JyCEUIrF8Np-EhniXmE,30613
+numba/tests/test_deprecations.py,sha256=J9_Y4eO_RDdxymBb15GvJex9e1ASzSkPupYSQrAlp1g,10186
+numba/tests/test_dictimpl.py,sha256=3ybNw_n9O0n7QmWMEmmLj_1IQcZnjTiQBEUMRwkAZPs,20038
+numba/tests/test_dictobject.py,sha256=QtWk2NPuwPCl0avzchECc-qfcX1mJnI8DYQNSV4hwX0,71361
+numba/tests/test_dicts.py,sha256=qNiyJx7wv_UcWuoeP2iDaXJjiWOO6sLncpCKgnuVr6s,6066
+numba/tests/test_dispatcher.py,sha256=v-bvjnA2edIGl0n3r8HjLljuFdCe3ytkXVu5DTKDduU,38541
+numba/tests/test_doctest.py,sha256=ntvCtFkfebvihMiW7NhAeFK9Mn5f3Om-DR4fiTburzI,795
+numba/tests/test_dyn_array.py,sha256=VM2w2fee_vspTMGbsruAFGJZ02glnkZo8QWdi85grMM,55791
+numba/tests/test_dyn_func.py,sha256=VeYpJCAymujXN1nBuyHl0W8pHS3cbpBDBpAGQ2CiYJM,811
+numba/tests/test_entrypoints.py,sha256=33rd8aC3S_B14v3T80KmdcLfC9Jk_Covn2EbV5Aljto,8152
+numba/tests/test_enums.py,sha256=svJ3SzcmpvnFe9jw9Ig56jpNtgZeZjEkA-bFrqU2q8k,4988
+numba/tests/test_errorhandling.py,sha256=cbao_2A78U9H52fc3Y1vSb3EH0uf1okm2w6gXhvsfaQ,15968
+numba/tests/test_errormodels.py,sha256=1Cxqp7-0pwdJlArxDyeohTAfImHYpMKb7_acbW7OqRA,585
+numba/tests/test_event.py,sha256=j0QylybHn5QEJhrVvQPyeI9F__kHrn4m7jpB9JRw6rE,7333
+numba/tests/test_exceptions.py,sha256=KgNWp8Neq2c9HDMys_iGpnTWS8WGMr1s_L7kQEZZtGY,16133
+numba/tests/test_extended_arg.py,sha256=M7CKc4Kiu0j0OYDuuvk_zxBruNHFGX7FC-uDATeEVDs,1571
+numba/tests/test_extending.py,sha256=t4ZSj_J9t7iWfQ_eTeCoZs6xlb1Oo39twVrg6LOBPOs,68201
+numba/tests/test_extending_types.py,sha256=3T4005XZFWOzscGAmNB6qwnC5HlVz4_AcsO47dW_Wvg,4990
+numba/tests/test_fancy_indexing.py,sha256=kAIO0Uk2J5fI56eL7e4NVf87JS2rx3mP2sIo8kZDgPI,19597
+numba/tests/test_fastmath.py,sha256=WmCUk3znkhiBhkxhTsudEaA4ci2B6UN_ZnfQky6ib4I,4564
+numba/tests/test_findlib.py,sha256=Tt9Xzn0-3EprPqAEt946-Ses3I8-YwYCN-hMi-ctfig,324
+numba/tests/test_firstlinefinder.py,sha256=m9cowyNiHonOtcydvL0fUfyBQzYJQhM9hjVZtK2wDJA,6831
+numba/tests/test_flow_control.py,sha256=LFuGkotUoJfGkZFWuz0Y3I1O0EXeVaj2tGChZbkNfUk,42671
+numba/tests/test_func_interface.py,sha256=pOMEhD3kH27XbNpe79TahiFRN8ueCcUanbNTwAH1OXg,1038
+numba/tests/test_func_lifetime.py,sha256=3cETb4trG71QeIMSN4foYos7DkZTLQufrc9ENs8ACmY,4908
+numba/tests/test_funcdesc.py,sha256=PJ4s19wiKGYUTlO5wpHNroM2H5ifddYsPiPpIgiKNv8,1698
+numba/tests/test_function_type.py,sha256=A5aFUTuGpgxzOhtTgl56DvcYjrytVYP_kDSCOgjwByQ,39010
+numba/tests/test_gdb_bindings.py,sha256=gPD5l-zxMGrhQziarBEC_QaGM0eoL38SRDBqgc2CRrg,8317
+numba/tests/test_gdb_dwarf.py,sha256=HYg0qUCIP0ucW1UGD85v0OLZ_Rr0Tfu4s3uP5B9Ytu0,9269
+numba/tests/test_generators.py,sha256=b_0h4IZfKRTnb-rWanA02GcP0t2neBOW3bQzIEVVKQo,16981
+numba/tests/test_getitem_on_types.py,sha256=hsEpV7IgJXWNUYP1L77xKaNujlbmOvbLK4uIdRc6ri4,3564
+numba/tests/test_gil.py,sha256=07knzRi9lQZFqEkcCUMnd9gE4IuYswkqya_wyyCAes8,5966
+numba/tests/test_globals.py,sha256=VQgRuotHnILWTfFY7Bg91VGxDsNmmMM2GKPF1AeXAiU,7329
+numba/tests/test_hashing.py,sha256=ss_UGyIxaCiHwUVcgu5y2ztLMgziDJ-8zITrpLOTAsI,19226
+numba/tests/test_heapq.py,sha256=VXHJSinvSStGoVQLpgBOx17G3ytBbKrsUBJezPUW_O4,14456
+numba/tests/test_help.py,sha256=VAYX2JIdCqrjtFuJo72r-_4Kj9iPcF8JSIKtRwxzSMs,3523
+numba/tests/test_import.py,sha256=NuydzvkFHh4Ig5G4WIWTo6Ay51Jj9d2oKP9RMakXYuc,4234
+numba/tests/test_indexing.py,sha256=PxuwFkrvhqdrASk9ZMsTqzCPoqm7SOvIztSdbLwqgI0,39134
+numba/tests/test_init_utils.py,sha256=GVZ3bG9xAfp6rWmfmtAYoJk9FyxyqhEq0VSBY9JA4M0,1557
+numba/tests/test_inlining.py,sha256=-pMzweKPnI9HkbgEUc4Kc3gzzm-UKYFP99Bi4HsvcAk,11520
+numba/tests/test_interpreter.py,sha256=qVSslKyVjndqJp5957QZz2nndMrRAGBYqsTuFI598vE,30293
+numba/tests/test_interproc.py,sha256=NLOub2C1frPWw7dlVKHTllI2_rLF5BcAzFEg4a3Fgkc,1099
+numba/tests/test_intwidth.py,sha256=A9JymBQSHZtQaGkQqmMOCKdbDgY97JMKnYjIEWVMdMg,2703
+numba/tests/test_ir.py,sha256=1rxR9bb41EyrlsJwRqlLBCroKSS-L0LbBNpCSt-98B4,20239
+numba/tests/test_ir_inlining.py,sha256=6e9AM6u2oup76ZhlCmm7Lz6YVuWmbaeFKtEOm99igjI,44716
+numba/tests/test_ir_utils.py,sha256=yTZuOjtAdGIq-TXicdblro-Vr5Gr00gYlzRaQa7MjbQ,9613
+numba/tests/test_itanium_mangler.py,sha256=eGG6LBnVcAXltL3laDLJuMnQN34gfI_GbGzaRXiPFbc,2561
+numba/tests/test_iteration.py,sha256=xyYG4PgnanlE7M9SNzv33vJo8PKNPC_pk8rd7D_vDBQ,7049
+numba/tests/test_jit_module.py,sha256=gAkHb87P2kk3ppThgeCWOdag-8PDhvQBdTvu0CmA0PY,5248
+numba/tests/test_jitclasses.py,sha256=Cn0sw8xj4ePSWUGUFLnaXaaIkHinR5BUlJBthwKNCkY,59870
+numba/tests/test_jitmethod.py,sha256=g2RTCmvFbNyNO4JaKcsLWeAdmrrOXrjB30pOUGyH_iU,2000
+numba/tests/test_linalg.py,sha256=xz6w0KYO3_FEuEi5muJA0AaCVkbFFXxKeFMLAs4Ybhw,96098
+numba/tests/test_listimpl.py,sha256=FEgWroRVAkeiorccJFwfmgLhXsJsyiCVkGvQzUvjESE,16147
+numba/tests/test_listobject.py,sha256=52f6E2RX0vASiB6d7CjmQ62tjmcFFGu9pUAHyx8dYkM,44676
+numba/tests/test_lists.py,sha256=ARmbrrb3sFU3yyUfBtI-XGlKEQl7gbBR_ngEWg-NNFY,51554
+numba/tests/test_literal_dispatch.py,sha256=cYQ6P4o7rYyJc6jNTV66-knNKo02B-anN3Ctccvplpk,11732
+numba/tests/test_llvm_pass_timings.py,sha256=z8MXzdlTAqIQ_KWFqPZCrULg4usUNCPk2eUm---59zQ,4493
+numba/tests/test_llvm_version_check.py,sha256=o8RSkDrsnljJ3xzbtsDQAkkqUEJwI3F2SEN9b1f1uMA,1284
+numba/tests/test_locals.py,sha256=8d61r5d1lkIXllE1ObI5oDZ1IwTTyeAtkHFaiLG4orw,335
+numba/tests/test_looplifting.py,sha256=-DjuAyC5e9DLNWJw1q5YB4DfslTeoSiVic4kIXlwh54,17273
+numba/tests/test_make_function_to_jit_function.py,sha256=JFsIpGLwunSUqImiWUcik_3AX7JRqRTY4qgZNMnPgmc,8288
+numba/tests/test_mandelbrot.py,sha256=ZLrAAKncKA74KLlgLbyfu6y7gp3FwZy_riAIwVlRkx4,595
+numba/tests/test_mangling.py,sha256=TtBFeN7EKTKtozvkwuAktbnKONG-bCH1jlHD-3n4EWw,1264
+numba/tests/test_map_filter_reduce.py,sha256=xyfL19UnK8WGXY2cNXBbiAKU7ZX3q5wZSVWZqaWLrYE,2031
+numba/tests/test_mathlib.py,sha256=lohGVCFAacVvaakttvVZTCv4D_S9QENhEeFi8IqQ980,17892
+numba/tests/test_maxmin.py,sha256=UDqYYUfJveub3U1xEqvjR_w1t7q67vPG86mZtizXzEA,747
+numba/tests/test_misc_coverage_support.py,sha256=bBKiVEMlYPRnDD15e1pZMXzTZydyZmIaUPW5-9wuz0Y,2952
+numba/tests/test_mixed_tuple_unroller.py,sha256=TMVAg_qm39WVfnz6XT_TZM4NgrLg7S20FeMAcOdBEfA,62041
+numba/tests/test_moved_modules.py,sha256=OcjNSGqNgvXwFQT0ipI4j8XP-ZbHPRFrXi1-8rjZIZE,1319
+numba/tests/test_multi3.py,sha256=hCHPIsHlx5wXW1PgkycrEVAxw7J1HGbn8NmnnbLN5Zw,1229
+numba/tests/test_nan.py,sha256=hmWtRaxUQvuBSQlfQkksgwaw4ZZ7Xjq6oyOktMnCU6M,751
+numba/tests/test_ndarray_subclasses.py,sha256=Jw2Zf5fanHlhihcp6BwzzxOlTYPhSQ3FcIdOOcK0v_0,10687
+numba/tests/test_nested_calls.py,sha256=Vb3wzSbS7dcqJq2K-8NFo_n0V37NCvm-tIX1r98aRpo,4082
+numba/tests/test_np_functions.py,sha256=KN6GbwBgRIrBebsWNu1gF9T4ooNKiazzYEeNB1c5kD0,241573
+numba/tests/test_np_randomgen.py,sha256=jp7Pj3sL_oXrfX9587Ou_wqohzHhs_ktbEkvSQqI5Ig,54301
+numba/tests/test_npdatetime.py,sha256=7j6Gb_MuY7STJCvYe6rDYMuWO0n09y3v5npzn9DAP8U,44289
+numba/tests/test_nrt.py,sha256=tBmx6Yoo2bcDD1YAlaDtw1IuQFknLyuQr62U7icpeUs,29806
+numba/tests/test_nrt_refct.py,sha256=k09EmgKBFPL3aCXBUaf7PYm9RmMXf3aqG2Fe2ZjR_Ic,2911
+numba/tests/test_num_threads.py,sha256=ZpuRV1hDfNYqStXZZ-pBkJP-8Iz7QKHjeTvJn1DyPMw,23511
+numba/tests/test_numberctor.py,sha256=uMpKKjN7S3quNI-ajwBxatwy12RHhbR8Parg1E4BYyw,7179
+numba/tests/test_numbers.py,sha256=iV9xS_t0FC0_ecUgva1pRY3-2_X3_1Xd58yk1oUw5hk,3415
+numba/tests/test_numconv.py,sha256=dFdTlZA1_agMuxP1OER02cKqZ-RR8dh0ES_69XdP20w,1008
+numba/tests/test_numpy_support.py,sha256=kJT2I4yjzibJ3lKthnumU5rX5DuIiROHzaY6rZ2FKTU,17873
+numba/tests/test_numpyadapt.py,sha256=f9iBBwwkwxrIpHC1Frp-bf0gl0oqcWhB9OwF3AzbuMk,1307
+numba/tests/test_obj_lifetime.py,sha256=g8N8pszctyim9xlC_SFdWlEkB9POJdXbi3E2NuOnPXU,15316
+numba/tests/test_object_mode.py,sha256=CC3peFxQudYVtpyMQVZxr2AkgF-ks3dgdnFDCVVvlmc,5798
+numba/tests/test_objects.py,sha256=RtRWC40agdYKfJubbWD2VUIp99U-8Vlel-KLAJOl4_o,1319
+numba/tests/test_operators.py,sha256=D1tFpKxSnZ7YdQJbLmMrmlYCTOtV4n3EGZFH_BmBI5I,50969
+numba/tests/test_optimisation_pipelines.py,sha256=z4n9_uQYGFPFOOAwth0IugJrWmcejyjBi9Pe4yigjpw,1692
+numba/tests/test_optional.py,sha256=0its7sre69mtSqePamMqOzudWdYGcdRYbcHWn99HeT4,6502
+numba/tests/test_overlap.py,sha256=P8MUVACNycTX54KFFmYzVlNxogayjlVspS9HtKZH-2w,3839
+numba/tests/test_parallel_backend.py,sha256=8PyoHAyXzkpuFf9Zzx2qvllZcYahPN1-B8nzTaypIKY,42150
+numba/tests/test_parfors.py,sha256=Z9Z63sn9J411crYlWEExxDXEXbzy_Jn-faxuBcmlEI4,166490
+numba/tests/test_parfors_caching.py,sha256=rf148DXLmLZNWFQgNCnW26lIBECRop4PufbWgk-pC7I,2962
+numba/tests/test_parfors_passes.py,sha256=TP_mY4NjR9dicGgOhSSeLqB3uxvYo2HwrbL40KfU254,21064
+numba/tests/test_pipeline.py,sha256=pqCu3ZyutdOxwGwPf2UEgh0BuajETlnb1m7UqwVjxV8,5254
+numba/tests/test_polynomial.py,sha256=wiK0QaSAV49M0DFNMGN_XfX8NLpxEdyc0ahWwLpmyzU,19776
+numba/tests/test_practical_lowering_issues.py,sha256=ecFnAiMhzk7fwxAHvvVXaoepQZDjhvW4U15ixnL0oRM,6953
+numba/tests/test_print.py,sha256=EaNmfFd8gx4RsLKc0d22fVtAdLqi4LMXEh3f03UJLFI,6144
+numba/tests/test_profiler.py,sha256=T-46A6_bMjHc3izo9zrmjIdZ7EQSewAbEAQ1AFK1AfM,4060
+numba/tests/test_pycc.py,sha256=Xtae_PZgZ29sa9eWRI6v7rpeO2HlWEtefatUBG4FkOg,14894
+numba/tests/test_python_int.py,sha256=bZhwlvC2KpAn1x0ID8HOerUpSuOULPMz-cLO4gNXVIs,1690
+numba/tests/test_pythonapi.py,sha256=pLN9H8hX-xP8SfWPLdh_OOC0dn7jOvrtY8j5trV3Rls,3935
+numba/tests/test_random.py,sha256=JHaXD0jLzSUTlceZWCLJJnRe3pyG7y_oh77O4ceJ-tg,74031
+numba/tests/test_range.py,sha256=sazrpcMDSYZPdT0lOkUb33GXerz2RaGITADFQZKOGU0,5643
+numba/tests/test_recarray_usecases.py,sha256=v5UuuUNowgDnJ3nx5vPKBNt00tQMZMg9BBQ6_KzWcjk,3839
+numba/tests/test_record_dtype.py,sha256=8TIJbFz92G6FmSuPys-ym2biuU_JTjVnG4lA0_3YLxE,57298
+numba/tests/test_recursion.py,sha256=K6Z1vT5beETZgN5Xz6qs-3vHP7zEY_KDT7XDjHJeshI,4602
+numba/tests/test_refop_pruning.py,sha256=JvoSR9phrGl4KiXAWJe_O_ongYAD0qgUFLTtz1AAn0Y,5950
+numba/tests/test_remove_dead.py,sha256=KUEbJ1uujvquy8exzEhpFeytZfYxm1CWRnTMvcQZxcc,13717
+numba/tests/test_repr.py,sha256=vMYY2byejl_KyZTB5JopGMKCD8NeYeNjnjJ_uYFRgdU,1656
+numba/tests/test_return_values.py,sha256=KCLvJRAoSJugioiXe45HZHAWbPGy35-v7TWi-joEodM,2062
+numba/tests/test_runtests.py,sha256=C7RCZ6u1XGDszfsg9qZceGuBfWLvrqmDUmBRSjYo5jk,11265
+numba/tests/test_serialize.py,sha256=UhQQCzPwzODqbI8DqROlLYyyYvaX9VKIsgg3mcH9MA8,11088
+numba/tests/test_setimpl.py,sha256=QZqH8IZpGAR8mlQbcQHs2Nf0WoFex-IsWkuHIQ41LE0,7635
+numba/tests/test_setobject.py,sha256=5hZ8K7XwxiDRbr2rrfCAEwt3KanEX-0xNlGkj8rJoPs,5207
+numba/tests/test_sets.py,sha256=2JbWMI63gfq85FoGfqYNF1XgPWodbI1SohfvSgvdTgo,23282
+numba/tests/test_slices.py,sha256=4zotg9-XrVJEyYf7AMWt5AwKp-luxJ-_nEIRHl-Oiy4,8449
+numba/tests/test_sort.py,sha256=ZM3jMJKfmQFDfkRoYVbOX9NEhOkMyQ_5U4lfjRyklLY,40848
+numba/tests/test_ssa.py,sha256=08zQ9c7R6FOL3iOoW6dlG2pwUU8Q8Wz0wXLh__5P1cE,18974
+numba/tests/test_stencils.py,sha256=OA7TyK4Mq1V6EHTaNLIflJPCQYEp5_zISkTts69aYII,127272
+numba/tests/test_storeslice.py,sha256=LVlURBWUfpaGUsk8TC5rv2uSLZM-FuPAnaz3PiEhFE0,1940
+numba/tests/test_struct_ref.py,sha256=lCVvc5HFXLVNrVhYRfbkgL5iRnuUhDiCsvNHS0ZIiKI,12458
+numba/tests/test_support.py,sha256=XToSTZabtQLbS8oALFCElZWNSQjVmltENakMcn37Uzk,14139
+numba/tests/test_svml.py,sha256=uYoS5Tmu0P4zpMc53dgS7aLTyB83TfuF0OCp8d7aeiw,15736
+numba/tests/test_sys_monitoring.py,sha256=55maYzv6n8W5fCnoq6Cpdp929iOLJaa-QTTRTFHAxmY,35472
+numba/tests/test_sys_stdin_assignment.py,sha256=NfkWGUZSKP9S1Ljr8FHjh58xnqTnOWrdh6OtEo8N148,1665
+numba/tests/test_sysinfo.py,sha256=Ja_Stj3ma9m9wmJUremtL83pTASNe4GwGBZ3ooCMD1Y,5842
+numba/tests/test_target_extension.py,sha256=wGmlHdocHb0CLD32Lf9saq01rNmsbbyYF-68X16dtEU,28255
+numba/tests/test_target_overloadselector.py,sha256=mLwsAg2bdMfVT9gZA1Xh40ejOpkHvrVpeuxn48PTSow,6226
+numba/tests/test_threadsafety.py,sha256=R-5T_uNcy27TX57izO7GuTf5WZXpkXdEiofc0VJT5QU,2787
+numba/tests/test_tracing.py,sha256=DC1Gabw7E9b3BzwdApxlE6oEM73nmQoYxBucL8jAoAU,4855
+numba/tests/test_try_except.py,sha256=HTdxPk4Bfu4Rg_ZOepHgT9w8aLIdcVgF6GcizKf1zYk,23887
+numba/tests/test_tuples.py,sha256=fbYmlJA7wtogDauMsiz6lZzicPqu3nK0F4ezt-yyTS4,23912
+numba/tests/test_typeconv.py,sha256=M3S82AjZTIiuBDx-AUZNfTOhrVIgT6tEPEPRB2XY5gQ,11167
+numba/tests/test_typedlist.py,sha256=w3IUmFnfZ8M2jC20ZOkCi1kgCMcrNud5SDrOdzoG-jE,50620
+numba/tests/test_typedobjectutils.py,sha256=wORlAhi7rywQ1JpHduOJDlZH_l_a7JAhEgqdSvdU5Ck,2352
+numba/tests/test_typeguard.py,sha256=0kLxdIvu-C6kcbSfBb2yI9Ylb4L3MCZ0T5oleiHEQuQ,1153
+numba/tests/test_typeinfer.py,sha256=BdSo9yQ9DoPUHTcEyUYxyNfYvZDWt7eIffHETa2svek,32790
+numba/tests/test_typenames.py,sha256=1LJcfCcSP8Ilqb9NMuFfRgszLGquaxFoPAwbuc43o1g,348
+numba/tests/test_typeof.py,sha256=nXjg6V9ELNCG0Yrfv_2PabB86SI7TA5l6fn4-XrH1rI,21678
+numba/tests/test_types.py,sha256=74sBbMrJQvKP1ST0FIvuElQQgyE2J-7cFspwueFMxd8,31236
+numba/tests/test_typingerror.py,sha256=zSFlST4KnTw2wNJe84mvYCIQxk3c-O5PXj9gnNw0dds,7235
+numba/tests/test_ufuncs.py,sha256=M5i1q2zkoow2o1rsn7p32Jw22gnYcSDQo_XXn7_Gv0E,71677
+numba/tests/test_unicode.py,sha256=72fcvRFVRRdwaphM8XRa6CFL5WDOxHjLPeXKXLOCV8c,98539
+numba/tests/test_unicode_array.py,sha256=DHLGut0dDX2n3KR0RmV4iSTRuWZYNF2KfiObwLuHqwI,28996
+numba/tests/test_unicode_names.py,sha256=YPJbxE4DzjQpFi7Wow7DGb4mwdqaTGTb5det8ayiupw,1563
+numba/tests/test_unpack_sequence.py,sha256=7edSjmBZUOJz0uxPsj1nELfYWlh0MxgN8nzxVjyuwDs,6745
+numba/tests/test_unpickle_without_module.py,sha256=OVLcy0Zwui5SPjr_Hs12ShxzhfPMmF7oS9XkX4iDQDo,1631
+numba/tests/test_unsafe_intrinsics.py,sha256=WCYZrNyu_70rX2ep7WgP5sw9vvOv730YWfQWO5j7oBo,7619
+numba/tests/test_usecases.py,sha256=gn3HkS--zzZ5U9b08oY2T5nzhySxg7AHlIyLiuacVMU,5893
+numba/tests/test_vectorization.py,sha256=tMLcZ6_7CPimUNwhymiQJGw7mInOktOc8mIhKi1zoyA,2932
+numba/tests/test_vectorization_type_inference.py,sha256=Hd9WtE3urYqslprNdKbbNk4X5lOzL2IM7aWr1rKAxrk,1162
+numba/tests/test_warnings.py,sha256=pm4J3GKggNbi2WWu6mmIazz7pDGT6E_-ZlUXOo6RvXw,7408
+numba/tests/test_withlifting.py,sha256=xDbtq5OUygvleCfJpKipzoIUGLPkdHIazlCDJbITsgM,35262
+numba/tests/threading_backend_usecases.py,sha256=q0In5DcjTg6LqAQY-Q1_WnmG7-4MhGBqIMDrSuysz8Y,618
+numba/tests/typedlist_usecases.py,sha256=Uo-2XbzPxNwPBeWh1U4yr7KkfEjADZ4NouO_PP6oX3o,287
+numba/tests/usecases.py,sha256=q5AbT3VfeLTN7P4whdfQ-851Y56BrnZ4K4EvbiegeLk,1618
+numba/typed/__init__.py,sha256=nq5XV0GfWezaRLTpui-gOTndStXFfaF1Vnv8vGnizro,508
+numba/typed/dictimpl.py,sha256=7qPLFW3ex2n1wmysA7IyZqehPoUHG6ICuiwVGXDLAU0,1101
+numba/typed/dictobject.py,sha256=AOiju2bCzq1o52JHVqAR6v6M9AKw99iHl4d4fgddPsA,40961
+numba/typed/listobject.py,sha256=bnWhzafxdzzkrrpd4dmnoeafMAdpLwaJCXFZw6zLum0,46028
+numba/typed/setobject.py,sha256=OWXu7qZQzvMi2tMY0ysnVQ4dOBn3K7ePMdLq4hYAntA,20236
+numba/typed/typeddict.py,sha256=tfQWKMur0hwxlOiaiy8fTxQ0O1gCPEPmhA33_NBV6QA,12216
+numba/typed/typedlist.py,sha256=0Mipv8f1LK3nOt6FfN1jImEzKzbt8OFpAfNAPAtpVJk,18791
+numba/typed/typedobjectutils.py,sha256=EsOTnBwYCQMG-IqoRsCDU1s3gbdlEJDjoCaYo8QZEGc,7036
+numba/typed/typedset.py,sha256=uC1cWjfZsfRawkefZi3eTF5SJAiNdudNk3AMAEeKREs,8226
+numba/types/__init__.py,sha256=bSQKeXj0suDD-j13RK4CxMnB5TXbgab4jo2536aMQI4,134

.venv/lib/python3.11/site-packages/numba-0.66.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_17_x86_64
+Tag: cp311-cp311-manylinux2014_x86_64
+

.venv/lib/python3.11/site-packages/numba-0.66.0.dist-info/licenses/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2012, Anaconda, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

.venv/lib/python3.11/site-packages/numba-0.66.0.dist-info/licenses/LICENSES.third-party

@@ -0,0 +1,569 @@
+The Numba source tree includes vendored libraries governed by the following
+licenses.
+
+
+appdirs
+-------
+
+# This is the MIT license
+
+Copyright (c) 2010 ActiveState Software Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+NetworkX
+--------
+The dominance frontier algorithm is from a pull request
+https://github.com/numba/numba/pull/4149/files which is based
+on the implementation of NetworkX of dominance. NetworkX has the following
+license:
+
+NetworkX is distributed with the 3-clause BSD license.
+
+::
+
+  Copyright (C) 2004-2019, NetworkX Developers
+  Aric Hagberg <hagberg@lanl.gov>
+  Dan Schult <dschult@colgate.edu>
+  Pieter Swart <swart@lanl.gov>
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are
+  met:
+
+   * Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+   * Redistributions in binary form must reproduce the above
+     copyright notice, this list of conditions and the following
+     disclaimer in the documentation and/or other materials provided
+     with the distribution.
+
+   * Neither the name of the NetworkX Developers nor the names of its
+     contributors may be used to endorse or promote products derived
+     from this software without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+jquery.graphviz.svg (https://github.com/mountainstorm/jquery.graphviz.svg/)
+---------------------------------------------------------------------------
+The DAG roadmap rendering code in docs/dagmap/ uses Javascript from this 
+package to draw graphs in HTML.
+
+Copyright (c) 2015 Mountainstorm
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+
+CPython (https://github.com/python/cpython)
+-------------------------------------------
+Numba source code that references URLs starting with:
+
+https://github.com/python/cpython/
+
+relates to use/inclusion of CPython source code which has the following license:
+
+A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
+as a successor of a language called ABC.  Guido remains Python's
+principal author, although it includes many contributions from others.
+
+In 1995, Guido continued his work on Python at the Corporation for
+National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
+in Reston, Virginia where he released several versions of the
+software.
+
+In May 2000, Guido and the Python core development team moved to
+BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
+year, the PythonLabs team moved to Digital Creations, which became
+Zope Corporation.  In 2001, the Python Software Foundation (PSF, see
+https://www.python.org/psf/) was formed, a non-profit organization
+created specifically to own Python-related Intellectual Property.
+Zope Corporation was a sponsoring member of the PSF.
+
+All Python releases are Open Source (see http://www.opensource.org for
+the Open Source Definition).  Historically, most, but not all, Python
+releases have also been GPL-compatible; the table below summarizes
+the various releases.
+
+    Release         Derived     Year        Owner       GPL-
+                    from                                compatible? (1)
+
+    0.9.0 thru 1.2              1991-1995   CWI         yes
+    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
+    1.6             1.5.2       2000        CNRI        no
+    2.0             1.6         2000        BeOpen.com  no
+    1.6.1           1.6         2001        CNRI        yes (2)
+    2.1             2.0+1.6.1   2001        PSF         no
+    2.0.1           2.0+1.6.1   2001        PSF         yes
+    2.1.1           2.1+2.0.1   2001        PSF         yes
+    2.1.2           2.1.1       2002        PSF         yes
+    2.1.3           2.1.2       2002        PSF         yes
+    2.2 and above   2.1.1       2001-now    PSF         yes
+
+Footnotes:
+
+(1) GPL-compatible doesn't mean that we're distributing Python under
+    the GPL.  All Python licenses, unlike the GPL, let you distribute
+    a modified version without making your changes open source.  The
+    GPL-compatible licenses make it possible to combine Python with
+    other software that is released under the GPL; the others don't.
+
+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+    because its license has a choice of law clause.  According to
+    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+    is "not incompatible" with the GPL.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 Python Software Foundation;
+All Rights Reserved" are retained in Python alone or in any derivative version
+prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions.  Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee.  This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party.  As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee.  Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement.  This Agreement together with
+Python 1.6.1 may be located on the Internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013.  This
+Agreement may also be obtained from a proxy server on the Internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee.  This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+        ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands.  All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+
+CPython unicode (https://github.com/python/cpython)
+---------------------------------------------------
+Numba's unicode support includes source code/algorithms from CPython's unicode
+implementation, Numba source code that has a reference starting with:
+
+https://github.com/python/cpython/
+
+and contains in the path "Objects/unicodeobject.c" relates to use/inclusion of
+CPython source code which has the following license along with the standard
+CPython license:
+
+
+Unicode implementation based on original code by Fredrik Lundh,
+modified by Marc-Andre Lemburg <mal@lemburg.com>.
+
+Major speed upgrades to the method implementations at the Reykjavik
+NeedForSpeed sprint, by Fredrik Lundh and Andrew Dalke.
+
+Copyright (c) Corporation for National Research Initiatives.
+
+--------------------------------------------------------------------
+The original string type implementation is:
+
+  Copyright (c) 1999 by Secret Labs AB
+  Copyright (c) 1999 by Fredrik Lundh
+
+By obtaining, using, and/or copying this software and/or its
+associated documentation, you agree that you have read, understood,
+and will comply with the following terms and conditions:
+
+Permission to use, copy, modify, and distribute this software and its
+associated documentation for any purpose and without fee is hereby
+granted, provided that the above copyright notice appears in all
+copies, and that both that copyright notice and this permission notice
+appear in supporting documentation, and that the name of Secret Labs
+AB or the author not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+--------------------------------------------------------------------
+
+
+cloudpickle
+-----------
+
+This module was extracted from the `cloud` package, developed by
+PiCloud, Inc.
+
+Copyright (c) 2015, Cloudpickle contributors.
+Copyright (c) 2012, Regents of the University of California.
+Copyright (c) 2009 PiCloud, Inc. http://www.picloud.com.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the University of California, Berkeley nor the
+      names of its contributors may be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+© 2020 GitHub, Inc.
+
+
+NumPy (https://github.com/numpy/numpy)
+--------------------------------------
+Numba source code that references URLs starting with:
+
+https://github.com/numpy/numpy
+
+relates to use of/inclusion of/derivate work based on NumPy source code which
+has the following license:
+
+
+Copyright (c) 2005-2021, NumPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+    * Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+       copyright notice, this list of conditions and the following
+       disclaimer in the documentation and/or other materials provided
+       with the distribution.
+
+    * Neither the name of the NumPy Developers nor the names of any
+       contributors may be used to endorse or promote products derived
+       from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+CUDA Half Precision Headers
+---------------------------
+
+The files numba/cuda/cuda_fp16.h and numba/cuda/cuda_fp16.hpp are vendored from
+the CUDA Toolkit version 11.2.2 under the terms of the NVIDIA Software License
+Agreement and CUDA Supplement to Software License Agreement, available at:
+
+https://docs.nvidia.com/cuda/archive/11.2.2/eula/index.html
+
+These files are distributable as listed in Attachment A:
+
+https://docs.nvidia.com/cuda/archive/11.2.2/eula/index.html#attachment-a
+
+
+pythoncapi_compat
+-----------------
+
+The file numba/pythoncapi_compat.h is vendored from 
+https://github.com/python/pythoncapi_compat under the terms of 
+the Zero Clause BSD (0BSD) license, which is available at: 
+https://github.com/python/pythoncapi-compat/blob/main/COPYING and its text is
+reproduced below:
+
+BSD Zero Clause License
+
+Copyright Contributors to the pythoncapi_compat project.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+numba-cuda
+----------
+Numba source code that references URLs starting with:
+
+https://github.com/NVIDIA/numba-cuda
+
+relates to use of/inclusion of/derivate work based on numba-cuda source code which
+has the following license:
+
+
+Copyright (c) 2012, Anaconda, Inc.
+Copyright (c) 2024, NVIDIA CORPORATION.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

.venv/lib/python3.11/site-packages/numba-0.66.0.dist-info/sboms/auditwheel.cdx.json

@@ -0,0 +1 @@
+{"bomFormat": "CycloneDX", "specVersion": "1.4", "version": 1, "metadata": {"component": {"type": "library", "bom-ref": "pkg:pypi/numba@0.66.0?file_name=numba-0.66.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", "name": "numba", "version": "0.66.0", "purl": "pkg:pypi/numba@0.66.0?file_name=numba-0.66.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl"}, "tools": [{"name": "auditwheel", "version": "6.7.0"}]}, "components": [{"type": "library", "bom-ref": "pkg:pypi/numba@0.66.0?file_name=numba-0.66.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", "name": "numba", "version": "0.66.0", "purl": "pkg:pypi/numba@0.66.0?file_name=numba-0.66.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl"}, {"type": "library", "bom-ref": "pkg:rpm/centos/libgomp@4.8.5-44.el7#c61017c9a24eb6e1e1a3cdc9becd004a6419cbda3d54b4848b98f240a4829571", "name": "libgomp", "version": "4.8.5-44.el7", "purl": "pkg:rpm/centos/libgomp@4.8.5-44.el7"}], "dependencies": [{"ref": "pkg:pypi/numba@0.66.0?file_name=numba-0.66.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", "dependsOn": ["pkg:rpm/centos/libgomp@4.8.5-44.el7#c61017c9a24eb6e1e1a3cdc9becd004a6419cbda3d54b4848b98f240a4829571"]}, {"ref": "pkg:rpm/centos/libgomp@4.8.5-44.el7#c61017c9a24eb6e1e1a3cdc9becd004a6419cbda3d54b4848b98f240a4829571"}]}

.venv/lib/python3.11/site-packages/numba-0.66.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+numba

.venv/lib/python3.11/site-packages/numba/pycc/modulemixin.c

@@ -0,0 +1,221 @@
+/*
+ * This C file is compiled and linked into pycc-generated shared objects.
+ * It provides the Numba helper functions for runtime use in pycc-compiled
+ * functions.
+ */
+
+#include "../_numba_common.h"
+#include "../_pymodule.h"
+
+/* Define all runtime-required symbols in this C module, but do not
+   export them outside the shared library if possible. */
+
+#define NUMBA_EXPORT_FUNC(_rettype) VISIBILITY_HIDDEN _rettype
+#define NUMBA_EXPORT_DATA(_vartype) VISIBILITY_HIDDEN _vartype
+
+#define PYCC_COMPILING
+
+#include "../_helperlib.c"
+#include "../_dynfunc.c"
+
+#if PYCC_USE_NRT
+#include "../core/runtime/_nrt_python.c"
+#include "../core/runtime/nrt.h"
+#endif
+
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION >= 12)
+    #define Py_BUILD_CORE 1
+    #include "internal/pycore_pyhash.h"
+    #undef Py_BUILD_CORE
+#endif
+
+/* Defines hashsecret variables (see issue #6386) */
+int64_t _numba_hashsecret_siphash_k0;
+int64_t _numba_hashsecret_siphash_k1;
+int64_t _numba_hashsecret_djbx33a_suffix;
+
+/* NOTE: import_array() is macro, not a function.  It returns NULL on
+   failure */
+static void *
+wrap_import_array(void) {
+    import_array();
+    return (void *) 1;
+}
+
+
+static int
+init_numpy(void) {
+    return wrap_import_array() != NULL;
+}
+
+
+#ifndef PYCC_MODULE_NAME
+#error PYCC_MODULE_NAME must be defined
+#endif
+
+/* Preprocessor trick: need to use two levels of macros otherwise
+   PYCC_MODULE_NAME would not get expanded */
+#define __PYCC(prefix, modname) prefix ## modname
+#define _PYCC(prefix, modname) __PYCC(prefix, modname)
+#define PYCC(prefix) _PYCC(prefix, PYCC_MODULE_NAME)
+
+/* Silence warnings about unused functions */
+VISIBILITY_HIDDEN void **PYCC(_unused_) = {
+    (void *) Numba_make_generator,
+};
+
+/* The structure type constructed by PythonAPI.serialize_uncached() */
+typedef struct {
+    const char *data;
+    int len;
+    const char *hashbuf;
+    const char *func_ptr;  // pointer to unwrap dyn args function
+    int alloc_flag;
+} env_def_t;
+
+/* Environment GlobalVariable address type */
+typedef void **env_gv_t;
+
+/*
+ * Recreate an environment object from a env_def_t structure.
+ */
+static EnvironmentObject *
+recreate_environment(PyObject *module, env_def_t env)
+{
+    EnvironmentObject *envobj;
+    PyObject *env_consts;
+
+    env_consts = numba_unpickle(env.data, env.len, env.hashbuf);
+    if (env_consts == NULL)
+        return NULL;
+    if (!PyList_Check(env_consts)) {
+        PyErr_Format(PyExc_TypeError,
+                     "environment constants should be a list, got '%s'",
+                     Py_TYPE(env_consts)->tp_name);
+        Py_DECREF(env_consts);
+        return NULL;
+    }
+
+    envobj = env_new_empty(&EnvironmentType);
+    if (envobj == NULL) {
+        Py_DECREF(env_consts);
+        return NULL;
+    }
+    envobj->consts = env_consts;
+    envobj->globals = PyModule_GetDict(module);
+    if (envobj->globals == NULL) {
+        Py_DECREF(envobj);
+        return NULL;
+    }
+    Py_INCREF(envobj->globals);
+    return envobj;
+}
+
+/*
+ * Subroutine to initialize all resources required for running the
+ * pycc-compiled functions.
+ */
+
+int
+PYCC(pycc_init_) (PyObject *module, PyMethodDef *defs,
+                                    env_def_t *envs,
+                                    env_gv_t *envgvs)
+{
+    /* Aligns hashsecret with values in current python process so that
+     * hashes computed inside the pycc module are correct if imported
+     * by the current process. Imports in a new process get the right
+     * hash secret through:
+     * `numba.cpython.hashing._load_hashsecret`.
+     */
+    _numba_hashsecret_siphash_k0 = _Py_HashSecret.siphash.k0;
+    _numba_hashsecret_siphash_k1 = _Py_HashSecret.siphash.k1;
+    _numba_hashsecret_djbx33a_suffix = _Py_HashSecret.djbx33a.suffix;
+
+    PyMethodDef *fdef;
+    PyObject *modname = NULL;
+    PyObject *docobj = NULL;
+    int i;
+
+    if (!init_numpy()) {
+        goto error;
+    }
+    if (init_dynfunc_module(module)) {
+        goto error;
+    }
+    /* Initialize random generation. */
+    numba_rnd_ensure_global_init();
+
+#if PYCC_USE_NRT
+    NRT_MemSys_init();
+    if (init_nrt_python_module(module)) {
+        goto error;
+    }
+#endif
+
+    modname = PyObject_GetAttrString(module, "__name__");
+    if (modname == NULL) {
+        goto error;
+    }
+
+    /* Empty docstring for all compiled functions */
+    docobj = PyString_FromString("");
+    if (docobj == NULL) {
+        goto error;
+    }
+
+    /* Overwrite C method objects with our own Closure objects, in order
+     * to make their environments available to the compiled functions.
+     */
+    for (i = 0, fdef = defs; fdef->ml_name != NULL; i++, fdef++) {
+        PyObject *func;
+        PyObject *nameobj;
+        EnvironmentObject *envobj;
+
+        envobj = recreate_environment(module, envs[i]);
+        if (envobj == NULL) {
+            goto error;
+        }
+        nameobj = PyString_FromString(fdef->ml_name);
+        if (nameobj == NULL) {
+            Py_DECREF(envobj);
+            goto error;
+        }
+        // Store the environment pointer into the global
+        *envgvs[i] = envobj;
+
+        func = pycfunction_new(module, nameobj, docobj,
+                               fdef->ml_meth, envobj, NULL);
+        Py_DECREF(envobj);
+        Py_DECREF(nameobj);
+
+        if (func == NULL) {
+            goto error;
+        }
+        if (PyObject_SetAttrString(module, fdef->ml_name, func)) {
+            Py_DECREF(func);
+            goto error;
+        }
+        Py_DECREF(func);
+    }
+    /* Recreate other environment objects 
+       envgvs is expected to end with a NULL pointer.
+    */
+    for (; envgvs[i]; ++i) {
+        EnvironmentObject *envobj;
+        envobj = recreate_environment(module, envs[i]);
+        if (envobj == NULL) {
+            goto error;
+        }
+        // Store the environment pointer into the global
+        *envgvs[i] = envobj;
+        Py_DECREF(envobj);
+    }
+    Py_DECREF(docobj);
+    Py_DECREF(modname);
+    return 0;
+
+error:
+    Py_XDECREF(docobj);
+    Py_XDECREF(modname);
+    return -1;
+}

.venv/lib/python3.11/site-packages/numba/pycc/platform.py

@@ -0,0 +1,218 @@
+import setuptools
+from setuptools.command.build_ext import build_ext
+from setuptools.dist import Distribution
+import numpy as np
+
+import functools
+import os
+import subprocess
+import sys
+from tempfile import mkdtemp
+from contextlib import contextmanager
+from pathlib import Path
+
+# Wire in distutils components from setuptools
+CCompiler =  setuptools.distutils.ccompiler.CCompiler
+new_compiler =  setuptools.distutils.ccompiler.new_compiler
+customize_compiler = setuptools.distutils.sysconfig.customize_compiler
+log = setuptools.distutils.log
+
+
+_configs = {
+    # DLL suffix, Python C extension suffix
+    'win': ('.dll', '.pyd'),
+    'default': ('.so', '.so'),
+}
+
+
+def get_configs(arg):
+    return _configs.get(sys.platform[:3], _configs['default'])[arg]
+
+
+find_shared_ending = functools.partial(get_configs, 0)
+find_pyext_ending = functools.partial(get_configs, 1)
+
+@contextmanager
+def _gentmpfile(suffix):
+    # windows locks the tempfile so use a tempdir + file, see
+    # https://github.com/numba/numba/issues/3304
+    try:
+        tmpdir = mkdtemp()
+        ntf = open(os.path.join(tmpdir, "temp%s" % suffix), 'wt')
+        yield ntf
+    finally:
+        try:
+            ntf.close()
+            os.remove(ntf)
+        except Exception:
+            pass
+        else:
+            os.rmdir(tmpdir)
+
+
+@functools.lru_cache(maxsize=1)
+def external_compiler_works():
+    """
+    Returns True if the "external compiler" bound in numpy.distutil is present
+    and working, False otherwise.
+    """
+    compiler = new_compiler()
+    customize_compiler(compiler)
+    for suffix in ['.c', '.cxx']:
+        try:
+            with _gentmpfile(suffix) as ntf:
+                simple_c = "int main(void) { return 0; }"
+                ntf.write(simple_c)
+                ntf.flush()
+                ntf.close()
+                # *output_dir* is set to avoid the compiler putting temp files
+                # in the current directory.
+                compiler.compile([ntf.name], output_dir=Path(ntf.name).anchor)
+        except Exception: # likely CompileError or file system issue
+            return False
+    return True
+
+
+class _DummyExtension(object):
+    libraries = []
+
+
+class Toolchain(object):
+
+    def __init__(self):
+        if not external_compiler_works():
+            self._raise_external_compiler_error()
+
+        self._verbose = False
+        self._compiler = new_compiler()
+        customize_compiler(self._compiler)
+        self._build_ext = build_ext(Distribution())
+        self._build_ext.finalize_options()
+        self._py_lib_dirs = self._build_ext.library_dirs
+        self._py_include_dirs = self._build_ext.include_dirs
+        np_compile_args = {'include_dirs': [np.get_include(),],}
+        if sys.platform == 'win32':
+            np_compile_args['libraries'] = []
+        else:
+            np_compile_args['libraries'] = ['m',]
+        self._math_info = np_compile_args
+
+    @property
+    def verbose(self):
+        return self._verbose
+
+    @verbose.setter
+    def verbose(self, value):
+        self._verbose = value
+        # DEBUG will let Numpy spew many messages, so stick to INFO
+        # to print commands executed by distutils
+        log.set_threshold(log.INFO if value else log.WARN)
+
+    def _raise_external_compiler_error(self):
+        basemsg = ("Attempted to compile AOT function without the "
+                   "compiler used by `numpy.distutils` present.")
+        conda_msg = "If using conda try:\n\n#> conda install %s"
+        plt = sys.platform
+        if plt.startswith('linux'):
+            if sys.maxsize <= 2 ** 32:
+                compilers = ['gcc_linux-32', 'gxx_linux-32']
+            else:
+                compilers = ['gcc_linux-64', 'gxx_linux-64']
+            msg = "%s %s" % (basemsg, conda_msg % ' '.join(compilers))
+        elif plt.startswith('darwin'):
+            compilers = ['clang_osx-64', 'clangxx_osx-64']
+            msg = "%s %s" % (basemsg, conda_msg % ' '.join(compilers))
+        elif plt.startswith('win32'):
+            winmsg = "Cannot find suitable msvc."
+            msg = "%s %s" % (basemsg, winmsg)
+        else:
+            msg = "Unknown platform %s" % plt
+        raise RuntimeError(msg)
+
+    def compile_objects(self, sources, output_dir,
+                        include_dirs=(), depends=(), macros=(),
+                        extra_cflags=None):
+        """
+        Compile the given source files into a separate object file each,
+        all beneath the *output_dir*.  A list of paths to object files
+        is returned.
+
+        *macros* has the same format as in distutils: a list of 1- or 2-tuples.
+        If a 1-tuple (name,), the given name is considered undefined by
+        the C preprocessor.
+        If a 2-tuple (name, value), the given name is expanded into the
+        given value by the C preprocessor.
+        """
+        objects = self._compiler.compile(sources,
+                                         output_dir=output_dir,
+                                         include_dirs=include_dirs,
+                                         depends=depends,
+                                         macros=macros or [],
+                                         extra_preargs=extra_cflags)
+        return objects
+
+    def link_shared(self, output, objects, libraries=(),
+                    library_dirs=(), export_symbols=(),
+                    extra_ldflags=None):
+        """
+        Create a shared library *output* linking the given *objects*
+        and *libraries* (all strings).
+        """
+        output_dir, output_filename = os.path.split(output)
+        self._compiler.link(CCompiler.SHARED_OBJECT, objects,
+                            output_filename, output_dir,
+                            libraries, library_dirs,
+                            export_symbols=export_symbols,
+                            extra_preargs=extra_ldflags)
+
+    def get_python_libraries(self):
+        """
+        Get the library arguments necessary to link with Python.
+        """
+        libs = self._build_ext.get_libraries(_DummyExtension())
+        if sys.platform == 'win32':
+            # Under Windows, need to link explicitly against the CRT,
+            # as the MSVC compiler would implicitly do.
+            # (XXX msvcrtd in pydebug mode?)
+            libs = libs + ['msvcrt']
+        return libs + self._math_info['libraries']
+
+    def get_python_library_dirs(self):
+        """
+        Get the library directories necessary to link with Python.
+        """
+        return list(self._py_lib_dirs)
+
+    def get_python_include_dirs(self):
+        """
+        Get the include directories necessary to compile against the Python
+        and Numpy C APIs.
+        """
+        return list(self._py_include_dirs) + self._math_info['include_dirs']
+
+    def get_ext_filename(self, ext_name):
+        """
+        Given a C extension's module name, return its intended filename.
+        """
+        return self._build_ext.get_ext_filename(ext_name)
+
+
+def _quote_arg(arg):
+    """
+    Quote the argument for safe use in a shell command line.
+    """
+    # If there is a quote in the string, assume relevants parts of the
+    # string are already quoted (e.g. '-I"C:\\Program Files\\..."')
+    if '"' not in arg and ' ' in arg:
+        return '"%s"' % arg
+    return arg
+
+
+def _is_sequence(arg):
+    if isinstance(arg, (str, bytes)):
+        return False
+    try:
+        len(arg)
+        return True
+    except Exception:
+        return False

.venv/lib/python3.11/site-packages/numba/pythoncapi_compat.h

@@ -0,0 +1,1696 @@
+// Header file providing new C API functions to old Python versions.
+//
+// File distributed under the Zero Clause BSD (0BSD) license.
+// Copyright Contributors to the pythoncapi_compat project.
+//
+// Homepage:
+// https://github.com/python/pythoncapi_compat
+//
+// Latest version:
+// https://raw.githubusercontent.com/python/pythoncapi-compat/0041177c4f348c8952b4c8980b2c90856e61c7c7/pythoncapi_compat.h
+//
+// SPDX-License-Identifier: 0BSD
+
+#ifndef PYTHONCAPI_COMPAT
+#define PYTHONCAPI_COMPAT
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <Python.h>
+
+// Python 3.11.0b4 added PyFrame_Back() to Python.h
+#if PY_VERSION_HEX < 0x030b00B4 && !defined(PYPY_VERSION)
+#  include "frameobject.h"        // PyFrameObject, PyFrame_GetBack()
+#endif
+
+
+#ifndef _Py_CAST
+#  define _Py_CAST(type, expr) ((type)(expr))
+#endif
+
+// Static inline functions should use _Py_NULL rather than using directly NULL
+// to prevent C++ compiler warnings. On C23 and newer and on C++11 and newer,
+// _Py_NULL is defined as nullptr.
+#if (defined (__STDC_VERSION__) && __STDC_VERSION__ > 201710L) \
+        || (defined(__cplusplus) && __cplusplus >= 201103)
+#  define _Py_NULL nullptr
+#else
+#  define _Py_NULL NULL
+#endif
+
+// Cast argument to PyObject* type.
+#ifndef _PyObject_CAST
+#  define _PyObject_CAST(op) _Py_CAST(PyObject*, op)
+#endif
+
+#ifndef Py_BUILD_ASSERT
+#  define Py_BUILD_ASSERT(cond) \
+        do { \
+            (void)sizeof(char [1 - 2 * !(cond)]); \
+        } while(0)
+#endif
+
+
+// bpo-42262 added Py_NewRef() to Python 3.10.0a3
+#if PY_VERSION_HEX < 0x030A00A3 && !defined(Py_NewRef)
+static inline PyObject* _Py_NewRef(PyObject *obj)
+{
+    Py_INCREF(obj);
+    return obj;
+}
+#define Py_NewRef(obj) _Py_NewRef(_PyObject_CAST(obj))
+#endif
+
+
+// bpo-42262 added Py_XNewRef() to Python 3.10.0a3
+#if PY_VERSION_HEX < 0x030A00A3 && !defined(Py_XNewRef)
+static inline PyObject* _Py_XNewRef(PyObject *obj)
+{
+    Py_XINCREF(obj);
+    return obj;
+}
+#define Py_XNewRef(obj) _Py_XNewRef(_PyObject_CAST(obj))
+#endif
+
+
+// bpo-39573 added Py_SET_REFCNT() to Python 3.9.0a4
+#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_REFCNT)
+static inline void _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt)
+{
+    ob->ob_refcnt = refcnt;
+}
+#define Py_SET_REFCNT(ob, refcnt) _Py_SET_REFCNT(_PyObject_CAST(ob), refcnt)
+#endif
+
+
+// Py_SETREF() and Py_XSETREF() were added to Python 3.5.2.
+// It is excluded from the limited C API.
+#if (PY_VERSION_HEX < 0x03050200 && !defined(Py_SETREF)) && !defined(Py_LIMITED_API)
+#define Py_SETREF(dst, src)                                     \
+    do {                                                        \
+        PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \
+        PyObject *_tmp_dst = (*_tmp_dst_ptr);                   \
+        *_tmp_dst_ptr = _PyObject_CAST(src);                    \
+        Py_DECREF(_tmp_dst);                                    \
+    } while (0)
+
+#define Py_XSETREF(dst, src)                                    \
+    do {                                                        \
+        PyObject **_tmp_dst_ptr = _Py_CAST(PyObject**, &(dst)); \
+        PyObject *_tmp_dst = (*_tmp_dst_ptr);                   \
+        *_tmp_dst_ptr = _PyObject_CAST(src);                    \
+        Py_XDECREF(_tmp_dst);                                   \
+    } while (0)
+#endif
+
+
+// bpo-43753 added Py_Is(), Py_IsNone(), Py_IsTrue() and Py_IsFalse()
+// to Python 3.10.0b1.
+#if PY_VERSION_HEX < 0x030A00B1 && !defined(Py_Is)
+#  define Py_Is(x, y) ((x) == (y))
+#endif
+#if PY_VERSION_HEX < 0x030A00B1 && !defined(Py_IsNone)
+#  define Py_IsNone(x) Py_Is(x, Py_None)
+#endif
+#if (PY_VERSION_HEX < 0x030A00B1 || defined(PYPY_VERSION)) && !defined(Py_IsTrue)
+#  define Py_IsTrue(x) Py_Is(x, Py_True)
+#endif
+#if (PY_VERSION_HEX < 0x030A00B1 || defined(PYPY_VERSION)) && !defined(Py_IsFalse)
+#  define Py_IsFalse(x) Py_Is(x, Py_False)
+#endif
+
+
+// bpo-39573 added Py_SET_TYPE() to Python 3.9.0a4
+#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_TYPE)
+static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type)
+{
+    ob->ob_type = type;
+}
+#define Py_SET_TYPE(ob, type) _Py_SET_TYPE(_PyObject_CAST(ob), type)
+#endif
+
+
+// bpo-39573 added Py_SET_SIZE() to Python 3.9.0a4
+#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_SET_SIZE)
+static inline void _Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size)
+{
+    ob->ob_size = size;
+}
+#define Py_SET_SIZE(ob, size) _Py_SET_SIZE((PyVarObject*)(ob), size)
+#endif
+
+
+// bpo-40421 added PyFrame_GetCode() to Python 3.9.0b1
+#if PY_VERSION_HEX < 0x030900B1 || defined(PYPY_VERSION)
+static inline PyCodeObject* PyFrame_GetCode(PyFrameObject *frame)
+{
+    assert(frame != _Py_NULL);
+    assert(frame->f_code != _Py_NULL);
+    return _Py_CAST(PyCodeObject*, Py_NewRef(frame->f_code));
+}
+#endif
+
+static inline PyCodeObject* _PyFrame_GetCodeBorrow(PyFrameObject *frame)
+{
+    PyCodeObject *code = PyFrame_GetCode(frame);
+    Py_DECREF(code);
+    return code;
+}
+
+
+// bpo-40421 added PyFrame_GetBack() to Python 3.9.0b1
+#if PY_VERSION_HEX < 0x030900B1 && !defined(PYPY_VERSION)
+static inline PyFrameObject* PyFrame_GetBack(PyFrameObject *frame)
+{
+    assert(frame != _Py_NULL);
+    return _Py_CAST(PyFrameObject*, Py_XNewRef(frame->f_back));
+}
+#endif
+
+#if !defined(PYPY_VERSION)
+static inline PyFrameObject* _PyFrame_GetBackBorrow(PyFrameObject *frame)
+{
+    PyFrameObject *back = PyFrame_GetBack(frame);
+    Py_XDECREF(back);
+    return back;
+}
+#endif
+
+
+// bpo-40421 added PyFrame_GetLocals() to Python 3.11.0a7
+#if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION)
+static inline PyObject* PyFrame_GetLocals(PyFrameObject *frame)
+{
+#if PY_VERSION_HEX >= 0x030400B1
+    if (PyFrame_FastToLocalsWithError(frame) < 0) {
+        return NULL;
+    }
+#else
+    PyFrame_FastToLocals(frame);
+#endif
+    return Py_NewRef(frame->f_locals);
+}
+#endif
+
+
+// bpo-40421 added PyFrame_GetGlobals() to Python 3.11.0a7
+#if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION)
+static inline PyObject* PyFrame_GetGlobals(PyFrameObject *frame)
+{
+    return Py_NewRef(frame->f_globals);
+}
+#endif
+
+
+// bpo-40421 added PyFrame_GetBuiltins() to Python 3.11.0a7
+#if PY_VERSION_HEX < 0x030B00A7 && !defined(PYPY_VERSION)
+static inline PyObject* PyFrame_GetBuiltins(PyFrameObject *frame)
+{
+    return Py_NewRef(frame->f_builtins);
+}
+#endif
+
+
+// bpo-40421 added PyFrame_GetLasti() to Python 3.11.0b1
+#if PY_VERSION_HEX < 0x030B00B1 && !defined(PYPY_VERSION)
+static inline int PyFrame_GetLasti(PyFrameObject *frame)
+{
+#if PY_VERSION_HEX >= 0x030A00A7
+    // bpo-27129: Since Python 3.10.0a7, f_lasti is an instruction offset,
+    // not a bytes offset anymore. Python uses 16-bit "wordcode" (2 bytes)
+    // instructions.
+    if (frame->f_lasti < 0) {
+        return -1;
+    }
+    return frame->f_lasti * 2;
+#else
+    return frame->f_lasti;
+#endif
+}
+#endif
+
+
+// gh-91248 added PyFrame_GetVar() to Python 3.12.0a2
+#if PY_VERSION_HEX < 0x030C00A2 && !defined(PYPY_VERSION)
+static inline PyObject* PyFrame_GetVar(PyFrameObject *frame, PyObject *name)
+{
+    PyObject *locals, *value;
+
+    locals = PyFrame_GetLocals(frame);
+    if (locals == NULL) {
+        return NULL;
+    }
+#if PY_VERSION_HEX >= 0x03000000
+    value = PyDict_GetItemWithError(locals, name);
+#else
+    value = _PyDict_GetItemWithError(locals, name);
+#endif
+    Py_DECREF(locals);
+
+    if (value == NULL) {
+        if (PyErr_Occurred()) {
+            return NULL;
+        }
+#if PY_VERSION_HEX >= 0x03000000
+        PyErr_Format(PyExc_NameError, "variable %R does not exist", name);
+#else
+        PyErr_SetString(PyExc_NameError, "variable does not exist");
+#endif
+        return NULL;
+    }
+    return Py_NewRef(value);
+}
+#endif
+
+
+// gh-91248 added PyFrame_GetVarString() to Python 3.12.0a2
+#if PY_VERSION_HEX < 0x030C00A2 && !defined(PYPY_VERSION)
+static inline PyObject*
+PyFrame_GetVarString(PyFrameObject *frame, const char *name)
+{
+    PyObject *name_obj, *value;
+#if PY_VERSION_HEX >= 0x03000000
+    name_obj = PyUnicode_FromString(name);
+#else
+    name_obj = PyString_FromString(name);
+#endif
+    if (name_obj == NULL) {
+        return NULL;
+    }
+    value = PyFrame_GetVar(frame, name_obj);
+    Py_DECREF(name_obj);
+    return value;
+}
+#endif
+
+
+// bpo-39947 added PyThreadState_GetInterpreter() to Python 3.9.0a5
+#if PY_VERSION_HEX < 0x030900A5 || defined(PYPY_VERSION)
+static inline PyInterpreterState *
+PyThreadState_GetInterpreter(PyThreadState *tstate)
+{
+    assert(tstate != _Py_NULL);
+    return tstate->interp;
+}
+#endif
+
+
+// bpo-40429 added PyThreadState_GetFrame() to Python 3.9.0b1
+#if PY_VERSION_HEX < 0x030900B1 && !defined(PYPY_VERSION)
+static inline PyFrameObject* PyThreadState_GetFrame(PyThreadState *tstate)
+{
+    assert(tstate != _Py_NULL);
+    return _Py_CAST(PyFrameObject *, Py_XNewRef(tstate->frame));
+}
+#endif
+
+#if !defined(PYPY_VERSION)
+static inline PyFrameObject*
+_PyThreadState_GetFrameBorrow(PyThreadState *tstate)
+{
+    PyFrameObject *frame = PyThreadState_GetFrame(tstate);
+    Py_XDECREF(frame);
+    return frame;
+}
+#endif
+
+
+// bpo-39947 added PyInterpreterState_Get() to Python 3.9.0a5
+#if PY_VERSION_HEX < 0x030900A5 || defined(PYPY_VERSION)
+static inline PyInterpreterState* PyInterpreterState_Get(void)
+{
+    PyThreadState *tstate;
+    PyInterpreterState *interp;
+
+    tstate = PyThreadState_GET();
+    if (tstate == _Py_NULL) {
+        Py_FatalError("GIL released (tstate is NULL)");
+    }
+    interp = tstate->interp;
+    if (interp == _Py_NULL) {
+        Py_FatalError("no current interpreter");
+    }
+    return interp;
+}
+#endif
+
+
+// bpo-39947 added PyInterpreterState_Get() to Python 3.9.0a6
+#if 0x030700A1 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030900A6 && !defined(PYPY_VERSION)
+static inline uint64_t PyThreadState_GetID(PyThreadState *tstate)
+{
+    assert(tstate != _Py_NULL);
+    return tstate->id;
+}
+#endif
+
+// bpo-43760 added PyThreadState_EnterTracing() to Python 3.11.0a2
+#if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION)
+static inline void PyThreadState_EnterTracing(PyThreadState *tstate)
+{
+    tstate->tracing++;
+#if PY_VERSION_HEX >= 0x030A00A1
+    tstate->cframe->use_tracing = 0;
+#else
+    tstate->use_tracing = 0;
+#endif
+}
+#endif
+
+// bpo-43760 added PyThreadState_LeaveTracing() to Python 3.11.0a2
+#if PY_VERSION_HEX < 0x030B00A2 && !defined(PYPY_VERSION)
+static inline void PyThreadState_LeaveTracing(PyThreadState *tstate)
+{
+    int use_tracing = (tstate->c_tracefunc != _Py_NULL
+                       || tstate->c_profilefunc != _Py_NULL);
+    tstate->tracing--;
+#if PY_VERSION_HEX >= 0x030A00A1
+    tstate->cframe->use_tracing = use_tracing;
+#else
+    tstate->use_tracing = use_tracing;
+#endif
+}
+#endif
+
+
+// bpo-37194 added PyObject_CallNoArgs() to Python 3.9.0a1
+// PyObject_CallNoArgs() added to PyPy 3.9.16-v7.3.11
+#if !defined(PyObject_CallNoArgs) && PY_VERSION_HEX < 0x030900A1
+static inline PyObject* PyObject_CallNoArgs(PyObject *func)
+{
+    return PyObject_CallFunctionObjArgs(func, NULL);
+}
+#endif
+
+
+// bpo-39245 made PyObject_CallOneArg() public (previously called
+// _PyObject_CallOneArg) in Python 3.9.0a4
+// PyObject_CallOneArg() added to PyPy 3.9.16-v7.3.11
+#if !defined(PyObject_CallOneArg) && PY_VERSION_HEX < 0x030900A4
+static inline PyObject* PyObject_CallOneArg(PyObject *func, PyObject *arg)
+{
+    return PyObject_CallFunctionObjArgs(func, arg, NULL);
+}
+#endif
+
+
+// bpo-1635741 added PyModule_AddObjectRef() to Python 3.10.0a3
+#if PY_VERSION_HEX < 0x030A00A3
+static inline int
+PyModule_AddObjectRef(PyObject *module, const char *name, PyObject *value)
+{
+    int res;
+
+    if (!value && !PyErr_Occurred()) {
+        // PyModule_AddObject() raises TypeError in this case
+        PyErr_SetString(PyExc_SystemError,
+                        "PyModule_AddObjectRef() must be called "
+                        "with an exception raised if value is NULL");
+        return -1;
+    }
+
+    Py_XINCREF(value);
+    res = PyModule_AddObject(module, name, value);
+    if (res < 0) {
+        Py_XDECREF(value);
+    }
+    return res;
+}
+#endif
+
+
+// bpo-40024 added PyModule_AddType() to Python 3.9.0a5
+#if PY_VERSION_HEX < 0x030900A5
+static inline int PyModule_AddType(PyObject *module, PyTypeObject *type)
+{
+    const char *name, *dot;
+
+    if (PyType_Ready(type) < 0) {
+        return -1;
+    }
+
+    // inline _PyType_Name()
+    name = type->tp_name;
+    assert(name != _Py_NULL);
+    dot = strrchr(name, '.');
+    if (dot != _Py_NULL) {
+        name = dot + 1;
+    }
+
+    return PyModule_AddObjectRef(module, name, _PyObject_CAST(type));
+}
+#endif
+
+
+// bpo-40241 added PyObject_GC_IsTracked() to Python 3.9.0a6.
+// bpo-4688 added _PyObject_GC_IS_TRACKED() to Python 2.7.0a2.
+#if PY_VERSION_HEX < 0x030900A6 && !defined(PYPY_VERSION)
+static inline int PyObject_GC_IsTracked(PyObject* obj)
+{
+    return (PyObject_IS_GC(obj) && _PyObject_GC_IS_TRACKED(obj));
+}
+#endif
+
+// bpo-40241 added PyObject_GC_IsFinalized() to Python 3.9.0a6.
+// bpo-18112 added _PyGCHead_FINALIZED() to Python 3.4.0 final.
+#if PY_VERSION_HEX < 0x030900A6 && PY_VERSION_HEX >= 0x030400F0 && !defined(PYPY_VERSION)
+static inline int PyObject_GC_IsFinalized(PyObject *obj)
+{
+    PyGC_Head *gc = _Py_CAST(PyGC_Head*, obj) - 1;
+    return (PyObject_IS_GC(obj) && _PyGCHead_FINALIZED(gc));
+}
+#endif
+
+
+// bpo-39573 added Py_IS_TYPE() to Python 3.9.0a4
+#if PY_VERSION_HEX < 0x030900A4 && !defined(Py_IS_TYPE)
+static inline int _Py_IS_TYPE(PyObject *ob, PyTypeObject *type) {
+    return Py_TYPE(ob) == type;
+}
+#define Py_IS_TYPE(ob, type) _Py_IS_TYPE(_PyObject_CAST(ob), type)
+#endif
+
+
+// bpo-46906 added PyFloat_Pack2() and PyFloat_Unpack2() to Python 3.11a7.
+// bpo-11734 added _PyFloat_Pack2() and _PyFloat_Unpack2() to Python 3.6.0b1.
+// Python 3.11a2 moved _PyFloat_Pack2() and _PyFloat_Unpack2() to the internal
+// C API: Python 3.11a2-3.11a6 versions are not supported.
+#if 0x030600B1 <= PY_VERSION_HEX && PY_VERSION_HEX <= 0x030B00A1 && !defined(PYPY_VERSION)
+static inline int PyFloat_Pack2(double x, char *p, int le)
+{ return _PyFloat_Pack2(x, (unsigned char*)p, le); }
+
+static inline double PyFloat_Unpack2(const char *p, int le)
+{ return _PyFloat_Unpack2((const unsigned char *)p, le); }
+#endif
+
+
+// bpo-46906 added PyFloat_Pack4(), PyFloat_Pack8(), PyFloat_Unpack4() and
+// PyFloat_Unpack8() to Python 3.11a7.
+// Python 3.11a2 moved _PyFloat_Pack4(), _PyFloat_Pack8(), _PyFloat_Unpack4()
+// and _PyFloat_Unpack8() to the internal C API: Python 3.11a2-3.11a6 versions
+// are not supported.
+#if PY_VERSION_HEX <= 0x030B00A1 && !defined(PYPY_VERSION)
+static inline int PyFloat_Pack4(double x, char *p, int le)
+{ return _PyFloat_Pack4(x, (unsigned char*)p, le); }
+
+static inline int PyFloat_Pack8(double x, char *p, int le)
+{ return _PyFloat_Pack8(x, (unsigned char*)p, le); }
+
+static inline double PyFloat_Unpack4(const char *p, int le)
+{ return _PyFloat_Unpack4((const unsigned char *)p, le); }
+
+static inline double PyFloat_Unpack8(const char *p, int le)
+{ return _PyFloat_Unpack8((const unsigned char *)p, le); }
+#endif
+
+
+// gh-92154 added PyCode_GetCode() to Python 3.11.0b1
+#if PY_VERSION_HEX < 0x030B00B1 && !defined(PYPY_VERSION)
+static inline PyObject* PyCode_GetCode(PyCodeObject *code)
+{
+    return Py_NewRef(code->co_code);
+}
+#endif
+
+
+// gh-95008 added PyCode_GetVarnames() to Python 3.11.0rc1
+#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION)
+static inline PyObject* PyCode_GetVarnames(PyCodeObject *code)
+{
+    return Py_NewRef(code->co_varnames);
+}
+#endif
+
+// gh-95008 added PyCode_GetFreevars() to Python 3.11.0rc1
+#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION)
+static inline PyObject* PyCode_GetFreevars(PyCodeObject *code)
+{
+    return Py_NewRef(code->co_freevars);
+}
+#endif
+
+// gh-95008 added PyCode_GetCellvars() to Python 3.11.0rc1
+#if PY_VERSION_HEX < 0x030B00C1 && !defined(PYPY_VERSION)
+static inline PyObject* PyCode_GetCellvars(PyCodeObject *code)
+{
+    return Py_NewRef(code->co_cellvars);
+}
+#endif
+
+
+// Py_UNUSED() was added to Python 3.4.0b2.
+#if PY_VERSION_HEX < 0x030400B2 && !defined(Py_UNUSED)
+#  if defined(__GNUC__) || defined(__clang__)
+#    define Py_UNUSED(name) _unused_ ## name __attribute__((unused))
+#  else
+#    define Py_UNUSED(name) _unused_ ## name
+#  endif
+#endif
+
+
+// gh-105922 added PyImport_AddModuleRef() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A0
+static inline PyObject* PyImport_AddModuleRef(const char *name)
+{
+    return Py_XNewRef(PyImport_AddModule(name));
+}
+#endif
+
+
+// gh-105927 added PyWeakref_GetRef() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D0000
+static inline int PyWeakref_GetRef(PyObject *ref, PyObject **pobj)
+{
+    PyObject *obj;
+    if (ref != NULL && !PyWeakref_Check(ref)) {
+        *pobj = NULL;
+        PyErr_SetString(PyExc_TypeError, "expected a weakref");
+        return -1;
+    }
+    obj = PyWeakref_GetObject(ref);
+    if (obj == NULL) {
+        // SystemError if ref is NULL
+        *pobj = NULL;
+        return -1;
+    }
+    if (obj == Py_None) {
+        *pobj = NULL;
+        return 0;
+    }
+    *pobj = Py_NewRef(obj);
+    return (*pobj != NULL);
+}
+#endif
+
+
+// bpo-36974 added PY_VECTORCALL_ARGUMENTS_OFFSET to Python 3.8b1
+#ifndef PY_VECTORCALL_ARGUMENTS_OFFSET
+#  define PY_VECTORCALL_ARGUMENTS_OFFSET (_Py_CAST(size_t, 1) << (8 * sizeof(size_t) - 1))
+#endif
+
+// bpo-36974 added PyVectorcall_NARGS() to Python 3.8b1
+#if PY_VERSION_HEX < 0x030800B1
+static inline Py_ssize_t PyVectorcall_NARGS(size_t n)
+{
+    return n & ~PY_VECTORCALL_ARGUMENTS_OFFSET;
+}
+#endif
+
+
+// gh-105922 added PyObject_Vectorcall() to Python 3.9.0a4
+#if PY_VERSION_HEX < 0x030900A4
+static inline PyObject*
+PyObject_Vectorcall(PyObject *callable, PyObject *const *args,
+                     size_t nargsf, PyObject *kwnames)
+{
+#if PY_VERSION_HEX >= 0x030800B1 && !defined(PYPY_VERSION)
+    // bpo-36974 added _PyObject_Vectorcall() to Python 3.8.0b1
+    return _PyObject_Vectorcall(callable, args, nargsf, kwnames);
+#else
+    PyObject *posargs = NULL, *kwargs = NULL;
+    PyObject *res;
+    Py_ssize_t nposargs, nkwargs, i;
+
+    if (nargsf != 0 && args == NULL) {
+        PyErr_BadInternalCall();
+        goto error;
+    }
+    if (kwnames != NULL && !PyTuple_Check(kwnames)) {
+        PyErr_BadInternalCall();
+        goto error;
+    }
+
+    nposargs = (Py_ssize_t)PyVectorcall_NARGS(nargsf);
+    if (kwnames) {
+        nkwargs = PyTuple_GET_SIZE(kwnames);
+    }
+    else {
+        nkwargs = 0;
+    }
+
+    posargs = PyTuple_New(nposargs);
+    if (posargs == NULL) {
+        goto error;
+    }
+    if (nposargs) {
+        for (i=0; i < nposargs; i++) {
+            PyTuple_SET_ITEM(posargs, i, Py_NewRef(*args));
+            args++;
+        }
+    }
+
+    if (nkwargs) {
+        kwargs = PyDict_New();
+        if (kwargs == NULL) {
+            goto error;
+        }
+
+        for (i = 0; i < nkwargs; i++) {
+            PyObject *key = PyTuple_GET_ITEM(kwnames, i);
+            PyObject *value = *args;
+            args++;
+            if (PyDict_SetItem(kwargs, key, value) < 0) {
+                goto error;
+            }
+        }
+    }
+    else {
+        kwargs = NULL;
+    }
+
+    res = PyObject_Call(callable, posargs, kwargs);
+    Py_DECREF(posargs);
+    Py_XDECREF(kwargs);
+    return res;
+
+error:
+    Py_DECREF(posargs);
+    Py_XDECREF(kwargs);
+    return NULL;
+#endif
+}
+#endif
+
+
+// gh-106521 added PyObject_GetOptionalAttr() and
+// PyObject_GetOptionalAttrString() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyObject_GetOptionalAttr(PyObject *obj, PyObject *attr_name, PyObject **result)
+{
+    // bpo-32571 added _PyObject_LookupAttr() to Python 3.7.0b1
+#if PY_VERSION_HEX >= 0x030700B1 && !defined(PYPY_VERSION)
+    return _PyObject_LookupAttr(obj, attr_name, result);
+#else
+    *result = PyObject_GetAttr(obj, attr_name);
+    if (*result != NULL) {
+        return 1;
+    }
+    if (!PyErr_Occurred()) {
+        return 0;
+    }
+    if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+        PyErr_Clear();
+        return 0;
+    }
+    return -1;
+#endif
+}
+
+static inline int
+PyObject_GetOptionalAttrString(PyObject *obj, const char *attr_name, PyObject **result)
+{
+    PyObject *name_obj;
+    int rc;
+#if PY_VERSION_HEX >= 0x03000000
+    name_obj = PyUnicode_FromString(attr_name);
+#else
+    name_obj = PyString_FromString(attr_name);
+#endif
+    if (name_obj == NULL) {
+        *result = NULL;
+        return -1;
+    }
+    rc = PyObject_GetOptionalAttr(obj, name_obj, result);
+    Py_DECREF(name_obj);
+    return rc;
+}
+#endif
+
+
+// gh-106307 added PyObject_GetOptionalAttr() and
+// PyMapping_GetOptionalItemString() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyMapping_GetOptionalItem(PyObject *obj, PyObject *key, PyObject **result)
+{
+    *result = PyObject_GetItem(obj, key);
+    if (*result) {
+        return 1;
+    }
+    if (!PyErr_ExceptionMatches(PyExc_KeyError)) {
+        return -1;
+    }
+    PyErr_Clear();
+    return 0;
+}
+
+static inline int
+PyMapping_GetOptionalItemString(PyObject *obj, const char *key, PyObject **result)
+{
+    PyObject *key_obj;
+    int rc;
+#if PY_VERSION_HEX >= 0x03000000
+    key_obj = PyUnicode_FromString(key);
+#else
+    key_obj = PyString_FromString(key);
+#endif
+    if (key_obj == NULL) {
+        *result = NULL;
+        return -1;
+    }
+    rc = PyMapping_GetOptionalItem(obj, key_obj, result);
+    Py_DECREF(key_obj);
+    return rc;
+}
+#endif
+
+// gh-108511 added PyMapping_HasKeyWithError() and
+// PyMapping_HasKeyStringWithError() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyMapping_HasKeyWithError(PyObject *obj, PyObject *key)
+{
+    PyObject *res;
+    int rc = PyMapping_GetOptionalItem(obj, key, &res);
+    Py_XDECREF(res);
+    return rc;
+}
+
+static inline int
+PyMapping_HasKeyStringWithError(PyObject *obj, const char *key)
+{
+    PyObject *res;
+    int rc = PyMapping_GetOptionalItemString(obj, key, &res);
+    Py_XDECREF(res);
+    return rc;
+}
+#endif
+
+
+// gh-108511 added PyObject_HasAttrWithError() and
+// PyObject_HasAttrStringWithError() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyObject_HasAttrWithError(PyObject *obj, PyObject *attr)
+{
+    PyObject *res;
+    int rc = PyObject_GetOptionalAttr(obj, attr, &res);
+    Py_XDECREF(res);
+    return rc;
+}
+
+static inline int
+PyObject_HasAttrStringWithError(PyObject *obj, const char *attr)
+{
+    PyObject *res;
+    int rc = PyObject_GetOptionalAttrString(obj, attr, &res);
+    Py_XDECREF(res);
+    return rc;
+}
+#endif
+
+
+// gh-106004 added PyDict_GetItemRef() and PyDict_GetItemStringRef()
+// to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyDict_GetItemRef(PyObject *mp, PyObject *key, PyObject **result)
+{
+#if PY_VERSION_HEX >= 0x03000000
+    PyObject *item = PyDict_GetItemWithError(mp, key);
+#else
+    PyObject *item = _PyDict_GetItemWithError(mp, key);
+#endif
+    if (item != NULL) {
+        *result = Py_NewRef(item);
+        return 1;  // found
+    }
+    if (!PyErr_Occurred()) {
+        *result = NULL;
+        return 0;  // not found
+    }
+    *result = NULL;
+    return -1;
+}
+
+static inline int
+PyDict_GetItemStringRef(PyObject *mp, const char *key, PyObject **result)
+{
+    int res;
+#if PY_VERSION_HEX >= 0x03000000
+    PyObject *key_obj = PyUnicode_FromString(key);
+#else
+    PyObject *key_obj = PyString_FromString(key);
+#endif
+    if (key_obj == NULL) {
+        *result = NULL;
+        return -1;
+    }
+    res = PyDict_GetItemRef(mp, key_obj, result);
+    Py_DECREF(key_obj);
+    return res;
+}
+#endif
+
+
+// gh-106307 added PyModule_Add() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyModule_Add(PyObject *mod, const char *name, PyObject *value)
+{
+    int res = PyModule_AddObjectRef(mod, name, value);
+    Py_XDECREF(value);
+    return res;
+}
+#endif
+
+
+// gh-108014 added Py_IsFinalizing() to Python 3.13.0a1
+// bpo-1856 added _Py_Finalizing to Python 3.2.1b1.
+// _Py_IsFinalizing() was added to PyPy 7.3.0.
+#if (0x030201B1 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x030D00A1) \
+        && (!defined(PYPY_VERSION_NUM) || PYPY_VERSION_NUM >= 0x7030000)
+static inline int Py_IsFinalizing(void)
+{
+#if PY_VERSION_HEX >= 0x030700A1
+    // _Py_IsFinalizing() was added to Python 3.7.0a1.
+    return _Py_IsFinalizing();
+#else
+    return (_Py_Finalizing != NULL);
+#endif
+}
+#endif
+
+
+// gh-108323 added PyDict_ContainsString() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int PyDict_ContainsString(PyObject *op, const char *key)
+{
+    PyObject *key_obj = PyUnicode_FromString(key);
+    if (key_obj == NULL) {
+        return -1;
+    }
+    int res = PyDict_Contains(op, key_obj);
+    Py_DECREF(key_obj);
+    return res;
+}
+#endif
+
+
+// gh-108445 added PyLong_AsInt() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int PyLong_AsInt(PyObject *obj)
+{
+#ifdef PYPY_VERSION
+    long value = PyLong_AsLong(obj);
+    if (value == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+    if (value < (long)INT_MIN || (long)INT_MAX < value) {
+        PyErr_SetString(PyExc_OverflowError,
+                        "Python int too large to convert to C int");
+        return -1;
+    }
+    return (int)value;
+#else
+    return _PyLong_AsInt(obj);
+#endif
+}
+#endif
+
+
+// gh-107073 added PyObject_VisitManagedDict() to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyObject_VisitManagedDict(PyObject *obj, visitproc visit, void *arg)
+{
+    PyObject **dict = _PyObject_GetDictPtr(obj);
+    if (*dict == NULL) {
+        return -1;
+    }
+    Py_VISIT(*dict);
+    return 0;
+}
+
+static inline void
+PyObject_ClearManagedDict(PyObject *obj)
+{
+    PyObject **dict = _PyObject_GetDictPtr(obj);
+    if (*dict == NULL) {
+        return;
+    }
+    Py_CLEAR(*dict);
+}
+#endif
+
+// gh-108867 added PyThreadState_GetUnchecked() to Python 3.13.0a1
+// Python 3.5.2 added _PyThreadState_UncheckedGet().
+#if PY_VERSION_HEX >= 0x03050200 && PY_VERSION_HEX < 0x030D00A1
+static inline PyThreadState*
+PyThreadState_GetUnchecked(void)
+{
+    return _PyThreadState_UncheckedGet();
+}
+#endif
+
+// gh-110289 added PyUnicode_EqualToUTF8() and PyUnicode_EqualToUTF8AndSize()
+// to Python 3.13.0a1
+#if PY_VERSION_HEX < 0x030D00A1
+static inline int
+PyUnicode_EqualToUTF8AndSize(PyObject *unicode, const char *str, Py_ssize_t str_len)
+{
+    Py_ssize_t len;
+    const void *utf8;
+    PyObject *exc_type, *exc_value, *exc_tb;
+    int res;
+
+    // API cannot report errors so save/restore the exception
+    PyErr_Fetch(&exc_type, &exc_value, &exc_tb);
+
+    // Python 3.3.0a1 added PyUnicode_AsUTF8AndSize()
+#if PY_VERSION_HEX >= 0x030300A1
+    if (PyUnicode_IS_ASCII(unicode)) {
+        utf8 = PyUnicode_DATA(unicode);
+        len = PyUnicode_GET_LENGTH(unicode);
+    }
+    else {
+        utf8 = PyUnicode_AsUTF8AndSize(unicode, &len);
+        if (utf8 == NULL) {
+            // Memory allocation failure. The API cannot report error,
+            // so ignore the exception and return 0.
+            res = 0;
+            goto done;
+        }
+    }
+
+    if (len != str_len) {
+        res = 0;
+        goto done;
+    }
+    res = (memcmp(utf8, str, (size_t)len) == 0);
+#else
+    PyObject *bytes = PyUnicode_AsUTF8String(unicode);
+    if (bytes == NULL) {
+        // Memory allocation failure. The API cannot report error,
+        // so ignore the exception and return 0.
+        res = 0;
+        goto done;
+    }
+
+#if PY_VERSION_HEX >= 0x03000000
+    len = PyBytes_GET_SIZE(bytes);
+    utf8 = PyBytes_AS_STRING(bytes);
+#else
+    len = PyString_GET_SIZE(bytes);
+    utf8 = PyString_AS_STRING(bytes);
+#endif
+    if (len != str_len) {
+        Py_DECREF(bytes);
+        res = 0;
+        goto done;
+    }
+
+    res = (memcmp(utf8, str, (size_t)len) == 0);
+    Py_DECREF(bytes);
+#endif
+
+done:
+    PyErr_Restore(exc_type, exc_value, exc_tb);
+    return res;
+}
+
+static inline int
+PyUnicode_EqualToUTF8(PyObject *unicode, const char *str)
+{
+    return PyUnicode_EqualToUTF8AndSize(unicode, str, (Py_ssize_t)strlen(str));
+}
+#endif
+
+
+// gh-111138 added PyList_Extend() and PyList_Clear() to Python 3.13.0a2
+#if PY_VERSION_HEX < 0x030D00A2
+static inline int
+PyList_Extend(PyObject *list, PyObject *iterable)
+{
+    return PyList_SetSlice(list, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, iterable);
+}
+
+static inline int
+PyList_Clear(PyObject *list)
+{
+    return PyList_SetSlice(list, 0, PY_SSIZE_T_MAX, NULL);
+}
+#endif
+
+// gh-111262 added PyDict_Pop() and PyDict_PopString() to Python 3.13.0a2
+#if PY_VERSION_HEX < 0x030D00A2
+static inline int
+PyDict_Pop(PyObject *dict, PyObject *key, PyObject **result)
+{
+    PyObject *value;
+
+    if (!PyDict_Check(dict)) {
+        PyErr_BadInternalCall();
+        if (result) {
+            *result = NULL;
+        }
+        return -1;
+    }
+
+    // bpo-16991 added _PyDict_Pop() to Python 3.5.0b2.
+    // Python 3.6.0b3 changed _PyDict_Pop() first argument type to PyObject*.
+    // Python 3.13.0a1 removed _PyDict_Pop().
+#if defined(PYPY_VERSION) || PY_VERSION_HEX < 0x030500b2 || PY_VERSION_HEX >= 0x030D0000
+    value = PyObject_CallMethod(dict, "pop", "O", key);
+#elif PY_VERSION_HEX < 0x030600b3
+    value = _PyDict_Pop(_Py_CAST(PyDictObject*, dict), key, NULL);
+#else
+    value = _PyDict_Pop(dict, key, NULL);
+#endif
+    if (value == NULL) {
+        if (result) {
+            *result = NULL;
+        }
+        if (PyErr_Occurred() && !PyErr_ExceptionMatches(PyExc_KeyError)) {
+            return -1;
+        }
+        PyErr_Clear();
+        return 0;
+    }
+    if (result) {
+        *result = value;
+    }
+    else {
+        Py_DECREF(value);
+    }
+    return 1;
+}
+
+static inline int
+PyDict_PopString(PyObject *dict, const char *key, PyObject **result)
+{
+    PyObject *key_obj = PyUnicode_FromString(key);
+    if (key_obj == NULL) {
+        if (result != NULL) {
+            *result = NULL;
+        }
+        return -1;
+    }
+
+    int res = PyDict_Pop(dict, key_obj, result);
+    Py_DECREF(key_obj);
+    return res;
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030200A4
+// Python 3.2.0a4 added Py_hash_t type
+typedef Py_ssize_t Py_hash_t;
+#endif
+
+
+// gh-111545 added Py_HashPointer() to Python 3.13.0a3
+#if PY_VERSION_HEX < 0x030D00A3
+static inline Py_hash_t Py_HashPointer(const void *ptr)
+{
+#if PY_VERSION_HEX >= 0x030900A4 && !defined(PYPY_VERSION)
+    return _Py_HashPointer(ptr);
+#else
+    return _Py_HashPointer(_Py_CAST(void*, ptr));
+#endif
+}
+#endif
+
+
+// Python 3.13a4 added a PyTime API.
+// Use the private API added to Python 3.5.
+#if PY_VERSION_HEX < 0x030D00A4 && PY_VERSION_HEX  >= 0x03050000
+typedef _PyTime_t PyTime_t;
+#define PyTime_MIN _PyTime_MIN
+#define PyTime_MAX _PyTime_MAX
+
+static inline double PyTime_AsSecondsDouble(PyTime_t t)
+{ return _PyTime_AsSecondsDouble(t); }
+
+static inline int PyTime_Monotonic(PyTime_t *result)
+{ return _PyTime_GetMonotonicClockWithInfo(result, NULL); }
+
+static inline int PyTime_Time(PyTime_t *result)
+{ return _PyTime_GetSystemClockWithInfo(result, NULL); }
+
+static inline int PyTime_PerfCounter(PyTime_t *result)
+{
+#if PY_VERSION_HEX >= 0x03070000 && !defined(PYPY_VERSION)
+    return _PyTime_GetPerfCounterWithInfo(result, NULL);
+#elif PY_VERSION_HEX >= 0x03070000
+    // Call time.perf_counter_ns() and convert Python int object to PyTime_t.
+    // Cache time.perf_counter_ns() function for best performance.
+    static PyObject *func = NULL;
+    if (func == NULL) {
+        PyObject *mod = PyImport_ImportModule("time");
+        if (mod == NULL) {
+            return -1;
+        }
+
+        func = PyObject_GetAttrString(mod, "perf_counter_ns");
+        Py_DECREF(mod);
+        if (func == NULL) {
+            return -1;
+        }
+    }
+
+    PyObject *res = PyObject_CallNoArgs(func);
+    if (res == NULL) {
+        return -1;
+    }
+    long long value = PyLong_AsLongLong(res);
+    Py_DECREF(res);
+
+    if (value == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+
+    Py_BUILD_ASSERT(sizeof(value) >= sizeof(PyTime_t));
+    *result = (PyTime_t)value;
+    return 0;
+#else
+    // Call time.perf_counter() and convert C double to PyTime_t.
+    // Cache time.perf_counter() function for best performance.
+    static PyObject *func = NULL;
+    if (func == NULL) {
+        PyObject *mod = PyImport_ImportModule("time");
+        if (mod == NULL) {
+            return -1;
+        }
+
+        func = PyObject_GetAttrString(mod, "perf_counter");
+        Py_DECREF(mod);
+        if (func == NULL) {
+            return -1;
+        }
+    }
+
+    PyObject *res = PyObject_CallNoArgs(func);
+    if (res == NULL) {
+        return -1;
+    }
+    double d = PyFloat_AsDouble(res);
+    Py_DECREF(res);
+
+    if (d == -1.0 && PyErr_Occurred()) {
+        return -1;
+    }
+
+    // Avoid floor() to avoid having to link to libm
+    *result = (PyTime_t)(d * 1e9);
+    return 0;
+#endif
+}
+
+#endif
+
+// gh-111389 added hash constants to Python 3.13.0a5. These constants were
+// added first as private macros to Python 3.4.0b1 and PyPy 7.3.9.
+#if (!defined(PyHASH_BITS) \
+     && ((!defined(PYPY_VERSION) && PY_VERSION_HEX >= 0x030400B1) \
+         || (defined(PYPY_VERSION) && PY_VERSION_HEX >= 0x03070000 \
+             && PYPY_VERSION_NUM >= 0x07090000)))
+#  define PyHASH_BITS _PyHASH_BITS
+#  define PyHASH_MODULUS _PyHASH_MODULUS
+#  define PyHASH_INF _PyHASH_INF
+#  define PyHASH_IMAG _PyHASH_IMAG
+#endif
+
+
+// gh-111545 added Py_GetConstant() and Py_GetConstantBorrowed()
+// to Python 3.13.0a6
+#if PY_VERSION_HEX < 0x030D00A6 && !defined(Py_CONSTANT_NONE)
+
+#define Py_CONSTANT_NONE 0
+#define Py_CONSTANT_FALSE 1
+#define Py_CONSTANT_TRUE 2
+#define Py_CONSTANT_ELLIPSIS 3
+#define Py_CONSTANT_NOT_IMPLEMENTED 4
+#define Py_CONSTANT_ZERO 5
+#define Py_CONSTANT_ONE 6
+#define Py_CONSTANT_EMPTY_STR 7
+#define Py_CONSTANT_EMPTY_BYTES 8
+#define Py_CONSTANT_EMPTY_TUPLE 9
+
+static inline PyObject* Py_GetConstant(unsigned int constant_id)
+{
+    static PyObject* constants[Py_CONSTANT_EMPTY_TUPLE + 1] = {NULL};
+
+    if (constants[Py_CONSTANT_NONE] == NULL) {
+        constants[Py_CONSTANT_NONE] = Py_None;
+        constants[Py_CONSTANT_FALSE] = Py_False;
+        constants[Py_CONSTANT_TRUE] = Py_True;
+        constants[Py_CONSTANT_ELLIPSIS] = Py_Ellipsis;
+        constants[Py_CONSTANT_NOT_IMPLEMENTED] = Py_NotImplemented;
+
+        constants[Py_CONSTANT_ZERO] = PyLong_FromLong(0);
+        if (constants[Py_CONSTANT_ZERO] == NULL) {
+            goto fatal_error;
+        }
+
+        constants[Py_CONSTANT_ONE] = PyLong_FromLong(1);
+        if (constants[Py_CONSTANT_ONE] == NULL) {
+            goto fatal_error;
+        }
+
+        constants[Py_CONSTANT_EMPTY_STR] = PyUnicode_FromStringAndSize("", 0);
+        if (constants[Py_CONSTANT_EMPTY_STR] == NULL) {
+            goto fatal_error;
+        }
+
+        constants[Py_CONSTANT_EMPTY_BYTES] = PyBytes_FromStringAndSize("", 0);
+        if (constants[Py_CONSTANT_EMPTY_BYTES] == NULL) {
+            goto fatal_error;
+        }
+
+        constants[Py_CONSTANT_EMPTY_TUPLE] = PyTuple_New(0);
+        if (constants[Py_CONSTANT_EMPTY_TUPLE] == NULL) {
+            goto fatal_error;
+        }
+        // goto dance to avoid compiler warnings about Py_FatalError()
+        goto init_done;
+
+fatal_error:
+        // This case should never happen
+        Py_FatalError("Py_GetConstant() failed to get constants");
+    }
+
+init_done:
+    if (constant_id <= Py_CONSTANT_EMPTY_TUPLE) {
+        return Py_NewRef(constants[constant_id]);
+    }
+    else {
+        PyErr_BadInternalCall();
+        return NULL;
+    }
+}
+
+static inline PyObject* Py_GetConstantBorrowed(unsigned int constant_id)
+{
+    PyObject *obj = Py_GetConstant(constant_id);
+    Py_XDECREF(obj);
+    return obj;
+}
+#endif
+
+
+// gh-114329 added PyList_GetItemRef() to Python 3.13.0a4
+#if PY_VERSION_HEX < 0x030D00A4
+static inline PyObject *
+PyList_GetItemRef(PyObject *op, Py_ssize_t index)
+{
+    PyObject *item = PyList_GetItem(op, index);
+    Py_XINCREF(item);
+    return item;
+}
+#endif
+
+
+// gh-114329 added PyList_GetItemRef() to Python 3.13.0a4
+#if PY_VERSION_HEX < 0x030D00A4
+static inline int
+PyDict_SetDefaultRef(PyObject *d, PyObject *key, PyObject *default_value,
+                     PyObject **result)
+{
+    PyObject *value;
+    if (PyDict_GetItemRef(d, key, &value) < 0) {
+        // get error
+        if (result) {
+            *result = NULL;
+        }
+        return -1;
+    }
+    if (value != NULL) {
+        // present
+        if (result) {
+            *result = value;
+        }
+        else {
+            Py_DECREF(value);
+        }
+        return 1;
+    }
+
+    // missing: set the item
+    if (PyDict_SetItem(d, key, default_value) < 0) {
+        // set error
+        if (result) {
+            *result = NULL;
+        }
+        return -1;
+    }
+    if (result) {
+        *result = Py_NewRef(default_value);
+    }
+    return 0;
+}
+#endif
+
+#if PY_VERSION_HEX < 0x030D00B3
+#  define Py_BEGIN_CRITICAL_SECTION(op) {
+#  define Py_END_CRITICAL_SECTION() }
+#  define Py_BEGIN_CRITICAL_SECTION2(a, b) {
+#  define Py_END_CRITICAL_SECTION2() }
+#endif
+
+#if PY_VERSION_HEX < 0x030E0000 && PY_VERSION_HEX >= 0x03060000 && !defined(PYPY_VERSION)
+typedef struct PyUnicodeWriter PyUnicodeWriter;
+
+static inline void PyUnicodeWriter_Discard(PyUnicodeWriter *writer)
+{
+    _PyUnicodeWriter_Dealloc((_PyUnicodeWriter*)writer);
+    PyMem_Free(writer);
+}
+
+static inline PyUnicodeWriter* PyUnicodeWriter_Create(Py_ssize_t length)
+{
+    if (length < 0) {
+        PyErr_SetString(PyExc_ValueError,
+                        "length must be positive");
+        return NULL;
+    }
+
+    const size_t size = sizeof(_PyUnicodeWriter);
+    PyUnicodeWriter *pub_writer = (PyUnicodeWriter *)PyMem_Malloc(size);
+    if (pub_writer == _Py_NULL) {
+        PyErr_NoMemory();
+        return _Py_NULL;
+    }
+    _PyUnicodeWriter *writer = (_PyUnicodeWriter *)pub_writer;
+
+    _PyUnicodeWriter_Init(writer);
+    if (_PyUnicodeWriter_Prepare(writer, length, 127) < 0) {
+        PyUnicodeWriter_Discard(pub_writer);
+        return NULL;
+    }
+    writer->overallocate = 1;
+    return pub_writer;
+}
+
+static inline PyObject* PyUnicodeWriter_Finish(PyUnicodeWriter *writer)
+{
+    PyObject *str = _PyUnicodeWriter_Finish((_PyUnicodeWriter*)writer);
+    assert(((_PyUnicodeWriter*)writer)->buffer == NULL);
+    PyMem_Free(writer);
+    return str;
+}
+
+static inline int
+PyUnicodeWriter_WriteChar(PyUnicodeWriter *writer, Py_UCS4 ch)
+{
+    if (ch > 0x10ffff) {
+        PyErr_SetString(PyExc_ValueError,
+                        "character must be in range(0x110000)");
+        return -1;
+    }
+
+    return _PyUnicodeWriter_WriteChar((_PyUnicodeWriter*)writer, ch);
+}
+
+static inline int
+PyUnicodeWriter_WriteStr(PyUnicodeWriter *writer, PyObject *obj)
+{
+    PyObject *str = PyObject_Str(obj);
+    if (str == NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str);
+    Py_DECREF(str);
+    return res;
+}
+
+static inline int
+PyUnicodeWriter_WriteRepr(PyUnicodeWriter *writer, PyObject *obj)
+{
+    PyObject *str = PyObject_Repr(obj);
+    if (str == NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str);
+    Py_DECREF(str);
+    return res;
+}
+
+static inline int
+PyUnicodeWriter_WriteUTF8(PyUnicodeWriter *writer,
+                          const char *str, Py_ssize_t size)
+{
+    if (size < 0) {
+        size = (Py_ssize_t)strlen(str);
+    }
+
+    PyObject *str_obj = PyUnicode_FromStringAndSize(str, size);
+    if (str_obj == _Py_NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str_obj);
+    Py_DECREF(str_obj);
+    return res;
+}
+
+static inline int
+PyUnicodeWriter_WriteWideChar(PyUnicodeWriter *writer,
+                              const wchar_t *str, Py_ssize_t size)
+{
+    if (size < 0) {
+        size = (Py_ssize_t)wcslen(str);
+    }
+
+    PyObject *str_obj = PyUnicode_FromWideChar(str, size);
+    if (str_obj == _Py_NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str_obj);
+    Py_DECREF(str_obj);
+    return res;
+}
+
+static inline int
+PyUnicodeWriter_WriteSubstring(PyUnicodeWriter *writer, PyObject *str,
+                               Py_ssize_t start, Py_ssize_t end)
+{
+    if (!PyUnicode_Check(str)) {
+        PyErr_Format(PyExc_TypeError, "expect str, not %T", str);
+        return -1;
+    }
+    if (start < 0 || start > end) {
+        PyErr_Format(PyExc_ValueError, "invalid start argument");
+        return -1;
+    }
+    if (end > PyUnicode_GET_LENGTH(str)) {
+        PyErr_Format(PyExc_ValueError, "invalid end argument");
+        return -1;
+    }
+
+    return _PyUnicodeWriter_WriteSubstring((_PyUnicodeWriter*)writer, str,
+                                           start, end);
+}
+
+static inline int
+PyUnicodeWriter_Format(PyUnicodeWriter *writer, const char *format, ...)
+{
+    va_list vargs;
+    va_start(vargs, format);
+    PyObject *str = PyUnicode_FromFormatV(format, vargs);
+    va_end(vargs);
+    if (str == _Py_NULL) {
+        return -1;
+    }
+
+    int res = _PyUnicodeWriter_WriteStr((_PyUnicodeWriter*)writer, str);
+    Py_DECREF(str);
+    return res;
+}
+#endif  // PY_VERSION_HEX < 0x030E0000
+
+// gh-116560 added PyLong_GetSign() to Python 3.14.0a0
+#if PY_VERSION_HEX < 0x030E00A0
+static inline int PyLong_GetSign(PyObject *obj, int *sign)
+{
+    if (!PyLong_Check(obj)) {
+        PyErr_Format(PyExc_TypeError, "expect int, got %s", Py_TYPE(obj)->tp_name);
+        return -1;
+    }
+
+    *sign = _PyLong_Sign(obj);
+    return 0;
+}
+#endif
+
+
+// gh-124502 added PyUnicode_Equal() to Python 3.14.0a0
+#if PY_VERSION_HEX < 0x030E00A0
+static inline int PyUnicode_Equal(PyObject *str1, PyObject *str2)
+{
+    if (!PyUnicode_Check(str1)) {
+        PyErr_Format(PyExc_TypeError, "first argument must be str, not %s",
+                     Py_TYPE(str1)->tp_name);
+        return -1;
+    }
+    if (!PyUnicode_Check(str2)) {
+        PyErr_Format(PyExc_TypeError, "second argument must be str, not %s",
+                     Py_TYPE(str2)->tp_name);
+        return -1;
+    }
+
+#if PY_VERSION_HEX >= 0x030d0000 && !defined(PYPY_VERSION)
+    PyAPI_FUNC(int) _PyUnicode_Equal(PyObject *str1, PyObject *str2);
+
+    return _PyUnicode_Equal(str1, str2);
+#elif PY_VERSION_HEX >= 0x03060000 && !defined(PYPY_VERSION)
+    return _PyUnicode_EQ(str1, str2);
+#elif PY_VERSION_HEX >= 0x03090000 && defined(PYPY_VERSION)
+    return _PyUnicode_EQ(str1, str2);
+#else
+    return (PyUnicode_Compare(str1, str2) == 0);
+#endif
+}
+#endif
+
+
+// gh-121645 added PyBytes_Join() to Python 3.14.0a0
+#if PY_VERSION_HEX < 0x030E00A0
+static inline PyObject* PyBytes_Join(PyObject *sep, PyObject *iterable)
+{
+    return _PyBytes_Join(sep, iterable);
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030E00A0
+static inline Py_hash_t Py_HashBuffer(const void *ptr, Py_ssize_t len)
+{
+#if PY_VERSION_HEX >= 0x03000000 && !defined(PYPY_VERSION)
+    PyAPI_FUNC(Py_hash_t) _Py_HashBytes(const void *src, Py_ssize_t len);
+
+    return _Py_HashBytes(ptr, len);
+#else
+    Py_hash_t hash;
+    PyObject *bytes = PyBytes_FromStringAndSize((const char*)ptr, len);
+    if (bytes == NULL) {
+        return -1;
+    }
+    hash = PyObject_Hash(bytes);
+    Py_DECREF(bytes);
+    return hash;
+#endif
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030E00A0
+static inline int PyIter_NextItem(PyObject *iter, PyObject **item)
+{
+    iternextfunc tp_iternext;
+
+    assert(iter != NULL);
+    assert(item != NULL);
+
+    tp_iternext = Py_TYPE(iter)->tp_iternext;
+    if (tp_iternext == NULL) {
+        *item = NULL;
+        PyErr_Format(PyExc_TypeError, "expected an iterator, got '%s'",
+                     Py_TYPE(iter)->tp_name);
+        return -1;
+    }
+
+    if ((*item = tp_iternext(iter))) {
+        return 1;
+    }
+    if (!PyErr_Occurred()) {
+        return 0;
+    }
+    if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
+        PyErr_Clear();
+        return 0;
+    }
+    return -1;
+}
+#endif
+
+
+#if PY_VERSION_HEX < 0x030E00A0
+static inline PyObject* PyLong_FromInt32(int32_t value)
+{
+    Py_BUILD_ASSERT(sizeof(long) >= 4);
+    return PyLong_FromLong(value);
+}
+
+static inline PyObject* PyLong_FromInt64(int64_t value)
+{
+    Py_BUILD_ASSERT(sizeof(long long) >= 8);
+    return PyLong_FromLongLong(value);
+}
+
+static inline PyObject* PyLong_FromUInt32(uint32_t value)
+{
+    Py_BUILD_ASSERT(sizeof(unsigned long) >= 4);
+    return PyLong_FromUnsignedLong(value);
+}
+
+static inline PyObject* PyLong_FromUInt64(uint64_t value)
+{
+    Py_BUILD_ASSERT(sizeof(unsigned long long) >= 8);
+    return PyLong_FromUnsignedLongLong(value);
+}
+
+static inline int PyLong_AsInt32(PyObject *obj, int32_t *pvalue)
+{
+    Py_BUILD_ASSERT(sizeof(int) == 4);
+    int value = PyLong_AsInt(obj);
+    if (value == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+    *pvalue = (int32_t)value;
+    return 0;
+}
+
+static inline int PyLong_AsInt64(PyObject *obj, int64_t *pvalue)
+{
+    Py_BUILD_ASSERT(sizeof(long long) == 8);
+    long long value = PyLong_AsLongLong(obj);
+    if (value == -1 && PyErr_Occurred()) {
+        return -1;
+    }
+    *pvalue = (int64_t)value;
+    return 0;
+}
+
+static inline int PyLong_AsUInt32(PyObject *obj, uint32_t *pvalue)
+{
+    Py_BUILD_ASSERT(sizeof(long) >= 4);
+    unsigned long value = PyLong_AsUnsignedLong(obj);
+    if (value == (unsigned long)-1 && PyErr_Occurred()) {
+        return -1;
+    }
+#if SIZEOF_LONG > 4
+    if ((unsigned long)UINT32_MAX < value) {
+        PyErr_SetString(PyExc_OverflowError,
+                        "Python int too large to convert to C uint32_t");
+        return -1;
+    }
+#endif
+    *pvalue = (uint32_t)value;
+    return 0;
+}
+
+static inline int PyLong_AsUInt64(PyObject *obj, uint64_t *pvalue)
+{
+    Py_BUILD_ASSERT(sizeof(long long) == 8);
+    unsigned long long value = PyLong_AsUnsignedLongLong(obj);
+    if (value == (unsigned long long)-1 && PyErr_Occurred()) {
+        return -1;
+    }
+    *pvalue = (uint64_t)value;
+    return 0;
+}
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif  // PYTHONCAPI_COMPAT

.venv/lib/python3.11/site-packages/numba/runtests.py

@@ -0,0 +1,9 @@
+from numba.testing._runtests import _main
+
+
+if __name__ == '__main__':
+    import sys
+    # For parallel testing under Windows
+    from multiprocessing import freeze_support
+    freeze_support()
+    sys.exit(0 if _main(sys.argv) else 1)

.venv/lib/python3.11/site-packages/numba/scripts/generate_lower_listing.py

@@ -0,0 +1,169 @@
+"""
+Generate documentation for all registered implementation for lowering
+using reStructured text.
+"""
+
+
+from subprocess import check_output
+
+import os.path
+try:
+    from StringIO import StringIO       # py2
+except ImportError:
+    from io import StringIO
+from collections import defaultdict
+import inspect
+from functools import partial
+
+import numba
+from numba.core.registry import cpu_target
+
+
+def git_hash():
+    out = check_output(['git', 'log', "--pretty=format:'%H'", '-n', '1'])
+    return out.decode('ascii').strip("'\"")
+
+
+def get_func_name(fn):
+    return getattr(fn, '__qualname__', fn.__name__)
+
+
+def gather_function_info(backend):
+    fninfos = defaultdict(list)
+    basepath = os.path.dirname(os.path.dirname(numba.__file__))
+    for fn, osel in backend._defns.items():
+        for sig, impl in osel.versions:
+            info = {}
+            fninfos[fn].append(info)
+            info['fn'] = fn
+            info['sig'] = sig
+            code, firstlineno = inspect.getsourcelines(impl)
+            path = inspect.getsourcefile(impl)
+            info['impl'] = {
+                'name': get_func_name(impl),
+                'filename': os.path.relpath(path, start=basepath),
+                'lines': (firstlineno, firstlineno + len(code) - 1),
+                'docstring': impl.__doc__
+            }
+
+    return fninfos
+
+
+def bind_file_to_print(fobj):
+    return partial(print, file=fobj)
+
+
+def format_signature(sig):
+    def fmt(c):
+        try:
+            return c.__name__
+        except AttributeError:
+            return repr(c).strip('\'"')
+    out = tuple(map(fmt, sig))
+    return '`({0})`'.format(', '.join(out))
+
+
+github_url = ('https://github.com/numba/numba/blob/'
+              '{commit}/{path}#L{firstline}-L{lastline}')
+
+description = """
+This lists all lowering definition registered to the CPU target.
+Each subsection corresponds to a Python function that is supported by numba
+nopython mode. These functions have one or more lower implementation with
+different signatures. The compiler chooses the most specific implementation
+from all overloads.
+"""
+
+
+def format_function_infos(fninfos):
+    buf = StringIO()
+    try:
+        print = bind_file_to_print(buf)
+
+        title_line = "Lowering Listing"
+        print(title_line)
+        print('=' * len(title_line))
+
+        print(description)
+
+        commit = git_hash()
+
+        def format_fname(fn):
+            try:
+                fname = "{0}.{1}".format(fn.__module__, get_func_name(fn))
+            except AttributeError:
+                fname = repr(fn)
+            return fn, fname
+
+        for fn, fname in sorted(map(format_fname, fninfos), key=lambda x: x[1]):
+            impinfos = fninfos[fn]
+            header_line = "``{0}``".format(fname)
+            print(header_line)
+            print('-' * len(header_line))
+            print()
+
+            formatted_sigs = map(
+                lambda x: format_signature(x['sig']), impinfos)
+            sorted_impinfos = sorted(zip(formatted_sigs, impinfos),
+                                     key=lambda x: x[0])
+
+            col_signatures = ['Signature']
+            col_urls = ['Definition']
+
+            for fmtsig, info in sorted_impinfos:
+                impl = info['impl']
+
+                filename = impl['filename']
+                lines = impl['lines']
+                fname = impl['name']
+
+                source = '{0} lines {1}-{2}'.format(filename, *lines)
+                link = github_url.format(commit=commit, path=filename,
+                                         firstline=lines[0], lastline=lines[1])
+                url = '``{0}`` `{1} <{2}>`_'.format(fname, source, link)
+
+                col_signatures.append(fmtsig)
+                col_urls.append(url)
+
+            # table formatting
+            max_width_col_sig = max(map(len, col_signatures))
+            max_width_col_url = max(map(len, col_urls))
+            padding = 2
+            width_col_sig = padding * 2 + max_width_col_sig
+            width_col_url = padding * 2 + max_width_col_url
+            line_format = "{{0:^{0}}}  {{1:^{1}}}".format(width_col_sig,
+                                                          width_col_url)
+            print(line_format.format('=' * width_col_sig, '=' * width_col_url))
+            print(line_format.format(col_signatures[0], col_urls[0]))
+            print(line_format.format('=' * width_col_sig, '=' * width_col_url))
+            for sig, url in zip(col_signatures[1:], col_urls[1:]):
+                print(line_format.format(sig, url))
+            print(line_format.format('=' * width_col_sig, '=' * width_col_url))
+            print()
+
+        return buf.getvalue()
+    finally:
+        buf.close()
+
+
+# Main routine for this module:
+
+def gen_lower_listing(path=None):
+    """
+    Generate lowering listing to ``path`` or (if None) to stdout.
+    """
+    cpu_backend = cpu_target.target_context
+    cpu_backend.refresh()
+
+    fninfos = gather_function_info(cpu_backend)
+    out = format_function_infos(fninfos)
+
+    if path is None:
+        print(out)
+    else:
+        with open(path, 'w') as fobj:
+            print(out, file=fobj)
+
+
+if __name__ == '__main__':
+    gen_lower_listing()

.venv/lib/python3.11/site-packages/numba/stencils/stencil.py

@@ -0,0 +1,836 @@
+#
+# Copyright (c) 2017 Intel Corporation
+# SPDX-License-Identifier: BSD-2-Clause
+#
+
+import copy
+
+import numpy as np
+from llvmlite import ir as lir
+
+from numba.core import types, typing, utils, ir, config, ir_utils, registry
+from numba.core.typing.templates import (CallableTemplate, signature,
+                                         infer_global, AbstractTemplate)
+from numba.core.imputils import lower_builtin
+from numba.core.extending import register_jitable
+from numba.core.errors import NumbaValueError
+from numba.misc.special import literal_unroll
+import numba
+
+import operator
+from numba.np import numpy_support
+
+class StencilFuncLowerer(object):
+    '''Callable class responsible for lowering calls to a specific StencilFunc.
+    '''
+    def __init__(self, sf):
+        self.stencilFunc = sf
+
+    def __call__(self, context, builder, sig, args):
+        cres = self.stencilFunc.compile_for_argtys(sig.args, {},
+                    sig.return_type, None)
+        res = context.call_internal(builder, cres.fndesc, sig, args)
+        context.add_linking_libs([cres.library])
+        return res
+
+@register_jitable
+def raise_if_incompatible_array_sizes(a, *args):
+    ashape = a.shape
+
+    # We need literal_unroll here because the stencil might take
+    # multiple input arrays with different types that are not compatible
+    # (e.g. values as float[:] and flags as bool[:])
+    # When more than three total arrays are given, the second and third
+    # are iterated over in the loop below. Without literal_unroll, their
+    # types have to match.
+    # An example failing signature without literal_unroll might be
+    # (float[:], float[:], bool[:]) (Just (float[:], bool[:]) wouldn't fail)
+    for arg in literal_unroll(args):
+        if a.ndim != arg.ndim:
+            raise ValueError("Secondary stencil array does not have same number "
+                             " of dimensions as the first stencil input.")
+        argshape = arg.shape
+        for i in range(len(ashape)):
+            if ashape[i] > argshape[i]:
+                raise ValueError("Secondary stencil array has some dimension "
+                                 "smaller the same dimension in the first "
+                                 "stencil input.")
+
+def slice_addition(the_slice, addend):
+    """ Called by stencil in Python mode to add the loop index to a
+        user-specified slice.
+    """
+    return slice(the_slice.start + addend, the_slice.stop + addend)
+
+class StencilFunc(object):
+    """
+    A special type to hold stencil information for the IR.
+    """
+
+    id_counter = 0
+
+    def __init__(self, kernel_ir, mode, options):
+        self.id = type(self).id_counter
+        type(self).id_counter += 1
+        self.kernel_ir = kernel_ir
+        self.mode = mode
+        self.options = options
+        self.kws = []       # remember original kws arguments
+
+        # stencils only supported for CPU context currently
+        self._typingctx = registry.cpu_target.typing_context
+        self._targetctx = registry.cpu_target.target_context
+        self._install_type(self._typingctx)
+        self.neighborhood = self.options.get("neighborhood")
+        self._type_cache = {}
+        self._lower_me = StencilFuncLowerer(self)
+
+    def replace_return_with_setitem(self, blocks, index_vars, out_name):
+        """
+        Find return statements in the IR and replace them with a SetItem
+        call of the value "returned" by the kernel into the result array.
+        Returns the block labels that contained return statements.
+        """
+        ret_blocks = []
+
+        for label, block in blocks.items():
+            scope = block.scope
+            loc = block.loc
+            new_body = []
+            for stmt in block.body:
+                if isinstance(stmt, ir.Return):
+                    ret_blocks.append(label)
+                    # If 1D array then avoid the tuple construction.
+                    if len(index_vars) == 1:
+                        rvar = ir.Var(scope, out_name, loc)
+                        ivar = ir.Var(scope, index_vars[0], loc)
+                        new_body.append(ir.SetItem(rvar, ivar, stmt.value, loc))
+                    else:
+                        # Convert the string names of the index variables into
+                        # ir.Var's.
+                        var_index_vars = []
+                        for one_var in index_vars:
+                            index_var = ir.Var(scope, one_var, loc)
+                            var_index_vars += [index_var]
+
+                        s_index_var = scope.redefine("stencil_index", loc)
+                        # Build a tuple from the index ir.Var's.
+                        tuple_call = ir.Expr.build_tuple(var_index_vars, loc)
+                        new_body.append(ir.Assign(tuple_call, s_index_var, loc))
+                        rvar = ir.Var(scope, out_name, loc)
+                        # Write the return statements original value into
+                        # the array using the tuple index.
+                        si = ir.SetItem(rvar, s_index_var, stmt.value, loc)
+                        new_body.append(si)
+                else:
+                    new_body.append(stmt)
+            block.body = new_body
+        return ret_blocks
+
+    def add_indices_to_kernel(self, kernel, index_names, ndim,
+                              neighborhood, standard_indexed, typemap, calltypes):
+        """
+        Transforms the stencil kernel as specified by the user into one
+        that includes each dimension's index variable as part of the getitem
+        calls.  So, in effect array[-1] becomes array[index0-1].
+        """
+        const_dict = {}
+        kernel_consts = []
+
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("add_indices_to_kernel", ndim, neighborhood)
+            ir_utils.dump_blocks(kernel.blocks)
+
+        if neighborhood is None:
+            need_to_calc_kernel = True
+        else:
+            need_to_calc_kernel = False
+            if len(neighborhood) != ndim:
+                raise NumbaValueError("%d dimensional neighborhood specified "
+                                      "for %d dimensional input array" %
+                                      (len(neighborhood), ndim))
+
+        tuple_table = ir_utils.get_tuple_table(kernel.blocks)
+
+        relatively_indexed = set()
+
+        for block in kernel.blocks.values():
+            scope = block.scope
+            loc = block.loc
+            new_body = []
+            for stmt in block.body:
+                if (isinstance(stmt, ir.Assign) and
+                    isinstance(stmt.value, ir.Const)):
+                    if config.DEBUG_ARRAY_OPT >= 1:
+                        print("remembering in const_dict", stmt.target.name,
+                              stmt.value.value)
+                    # Remember consts for use later.
+                    const_dict[stmt.target.name] = stmt.value.value
+                if ((isinstance(stmt, ir.Assign)
+                        and isinstance(stmt.value, ir.Expr)
+                        and stmt.value.op in ['setitem', 'static_setitem']
+                        and stmt.value.value.name in kernel.arg_names) or
+                   (isinstance(stmt, ir.SetItem)
+                        and stmt.target.name in kernel.arg_names)):
+                    raise NumbaValueError("Assignments to arrays passed to " \
+                                          "stencil kernels is not allowed.")
+                if (isinstance(stmt, ir.Assign)
+                        and isinstance(stmt.value, ir.Expr)
+                        and stmt.value.op in ['getitem', 'static_getitem']
+                        and stmt.value.value.name in kernel.arg_names
+                        and stmt.value.value.name not in standard_indexed):
+                    # We found a getitem from the input array.
+                    if stmt.value.op == 'getitem':
+                        stmt_index_var = stmt.value.index
+                    else:
+                        stmt_index_var = stmt.value.index_var
+                        # allow static_getitem since rewrite passes are applied
+                        #raise ValueError("Unexpected static_getitem in add_indices_to_kernel.")
+
+                    relatively_indexed.add(stmt.value.value.name)
+
+                    # Store the index used after looking up the variable in
+                    # the const dictionary.
+                    if need_to_calc_kernel:
+                        assert hasattr(stmt_index_var, 'name')
+
+                        if stmt_index_var.name in tuple_table:
+                            kernel_consts += [tuple_table[stmt_index_var.name]]
+                        elif stmt_index_var.name in const_dict:
+                            kernel_consts += [const_dict[stmt_index_var.name]]
+                        else:
+                            raise NumbaValueError("stencil kernel index is not "
+                                "constant, 'neighborhood' option required")
+
+                    if ndim == 1:
+                        # Single dimension always has index variable 'index0'.
+                        # tmpvar will hold the real index and is computed by
+                        # adding the relative offset in stmt.value.index to
+                        # the current absolute location in index0.
+                        index_var = ir.Var(scope, index_names[0], loc)
+                        tmpvar = scope.redefine("stencil_index", loc)
+                        stmt_index_var_typ = typemap[stmt_index_var.name]
+                        # If the array is indexed with a slice then we
+                        # have to add the index value with a call to
+                        # slice_addition.
+                        if isinstance(stmt_index_var_typ, types.misc.SliceType):
+                            sa_var = scope.redefine("slice_addition", loc)
+                            sa_func = numba.njit(slice_addition)
+                            sa_func_typ = types.functions.Dispatcher(sa_func)
+                            typemap[sa_var.name] = sa_func_typ
+                            g_sa = ir.Global("slice_addition", sa_func, loc)
+                            new_body.append(ir.Assign(g_sa, sa_var, loc))
+                            slice_addition_call = ir.Expr.call(sa_var, [stmt_index_var, index_var], (), loc)
+                            calltypes[slice_addition_call] = sa_func_typ.get_call_type(self._typingctx, [stmt_index_var_typ, types.intp], {})
+                            new_body.append(ir.Assign(slice_addition_call, tmpvar, loc))
+                            new_body.append(ir.Assign(
+                                           ir.Expr.getitem(stmt.value.value, tmpvar, loc),
+                                           stmt.target, loc))
+                        else:
+                            acc_call = ir.Expr.binop(operator.add, stmt_index_var,
+                                                     index_var, loc)
+                            new_body.append(ir.Assign(acc_call, tmpvar, loc))
+                            new_body.append(ir.Assign(
+                                           ir.Expr.getitem(stmt.value.value, tmpvar, loc),
+                                           stmt.target, loc))
+                    else:
+                        index_vars = []
+                        sum_results = []
+                        s_index_var = scope.redefine("stencil_index", loc)
+                        const_index_vars = []
+                        ind_stencils = []
+
+                        stmt_index_var_typ = typemap[stmt_index_var.name]
+                        # Same idea as above but you have to extract
+                        # individual elements out of the tuple indexing
+                        # expression and add the corresponding index variable
+                        # to them and then reconstitute as a tuple that can
+                        # index the array.
+                        for dim in range(ndim):
+                            tmpvar = scope.redefine("const_index", loc)
+                            new_body.append(ir.Assign(ir.Const(dim, loc),
+                                                      tmpvar, loc))
+                            const_index_vars += [tmpvar]
+                            index_var = ir.Var(scope, index_names[dim], loc)
+                            index_vars += [index_var]
+
+                            tmpvar = scope.redefine("ind_stencil_index", loc)
+                            ind_stencils += [tmpvar]
+                            getitemvar = scope.redefine("getitem", loc)
+                            getitemcall = ir.Expr.getitem(stmt_index_var,
+                                                       const_index_vars[dim], loc)
+                            new_body.append(ir.Assign(getitemcall, getitemvar, loc))
+                            # Get the type of this particular part of the index tuple.
+                            if isinstance(stmt_index_var_typ, types.ConstSized):
+                                one_index_typ = stmt_index_var_typ[dim]
+                            else:
+                                one_index_typ = stmt_index_var_typ[:]
+                            # If the array is indexed with a slice then we
+                            # have to add the index value with a call to
+                            # slice_addition.
+                            if isinstance(one_index_typ, types.misc.SliceType):
+                                sa_var = scope.redefine("slice_addition", loc)
+                                sa_func = numba.njit(slice_addition)
+                                sa_func_typ = types.functions.Dispatcher(sa_func)
+                                typemap[sa_var.name] = sa_func_typ
+                                g_sa = ir.Global("slice_addition", sa_func, loc)
+                                new_body.append(ir.Assign(g_sa, sa_var, loc))
+                                slice_addition_call = ir.Expr.call(sa_var, [getitemvar, index_vars[dim]], (), loc)
+                                calltypes[slice_addition_call] = sa_func_typ.get_call_type(self._typingctx, [one_index_typ, types.intp], {})
+                                new_body.append(ir.Assign(slice_addition_call, tmpvar, loc))
+                            else:
+                                acc_call = ir.Expr.binop(operator.add, getitemvar,
+                                                         index_vars[dim], loc)
+                                new_body.append(ir.Assign(acc_call, tmpvar, loc))
+
+                        tuple_call = ir.Expr.build_tuple(ind_stencils, loc)
+                        new_body.append(ir.Assign(tuple_call, s_index_var, loc))
+                        new_body.append(ir.Assign(
+                                  ir.Expr.getitem(stmt.value.value,s_index_var,loc),
+                                  stmt.target,loc))
+                else:
+                    new_body.append(stmt)
+            block.body = new_body
+
+        if need_to_calc_kernel:
+            # Find the size of the kernel by finding the maximum absolute value
+            # index used in the kernel specification.
+            neighborhood = [[0,0] for _ in range(ndim)]
+            if len(kernel_consts) == 0:
+                raise NumbaValueError("Stencil kernel with no accesses to "
+                                      "relatively indexed arrays.")
+
+            for index in kernel_consts:
+                if isinstance(index, tuple) or isinstance(index, list):
+                    for i in range(len(index)):
+                        te = index[i]
+                        if isinstance(te, ir.Var) and te.name in const_dict:
+                            te = const_dict[te.name]
+                        if isinstance(te, int):
+                            neighborhood[i][0] = min(neighborhood[i][0], te)
+                            neighborhood[i][1] = max(neighborhood[i][1], te)
+                        else:
+                            raise NumbaValueError(
+                                "stencil kernel index is not constant,"
+                                "'neighborhood' option required")
+                    index_len = len(index)
+                elif isinstance(index, int):
+                    neighborhood[0][0] = min(neighborhood[0][0], index)
+                    neighborhood[0][1] = max(neighborhood[0][1], index)
+                    index_len = 1
+                else:
+                    raise NumbaValueError(
+                        "Non-tuple or non-integer used as stencil index.")
+                if index_len != ndim:
+                    raise NumbaValueError(
+                        "Stencil index does not match array dimensionality.")
+
+        return (neighborhood, relatively_indexed)
+
+
+    def get_return_type(self, argtys):
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("get_return_type", argtys)
+            ir_utils.dump_blocks(self.kernel_ir.blocks)
+
+        if not isinstance(argtys[0], types.npytypes.Array):
+            raise NumbaValueError("The first argument to a stencil kernel must "
+                                  "be the primary input array.")
+
+        from numba.core import typed_passes
+        typemap, return_type, calltypes, _ = typed_passes.type_inference_stage(
+                self._typingctx,
+                self._targetctx,
+                self.kernel_ir,
+                argtys,
+                None,
+                {})
+        if isinstance(return_type, types.npytypes.Array):
+            raise NumbaValueError(
+                "Stencil kernel must return a scalar and not a numpy array.")
+
+        real_ret = types.npytypes.Array(return_type, argtys[0].ndim,
+                                                     argtys[0].layout)
+        return (real_ret, typemap, calltypes)
+
+    def _install_type(self, typingctx):
+        """Constructs and installs a typing class for a StencilFunc object in
+        the input typing context.
+        """
+        _ty_cls = type('StencilFuncTyping_' +
+                       str(self.id),
+                       (AbstractTemplate,),
+                       dict(key=self, generic=self._type_me))
+        typingctx.insert_user_function(self, _ty_cls)
+
+    def compile_for_argtys(self, argtys, kwtys, return_type, sigret):
+        # look in the type cache to find if result array is passed
+        (_, result, typemap, calltypes) = self._type_cache[argtys]
+        new_func = self._stencil_wrapper(result, sigret, return_type,
+                                         typemap, calltypes, *argtys)
+        return new_func
+
+    def _type_me(self, argtys, kwtys):
+        """
+        Implement AbstractTemplate.generic() for the typing class
+        built by StencilFunc._install_type().
+        Return the call-site signature.
+        """
+        if (self.neighborhood is not None and
+            len(self.neighborhood) != argtys[0].ndim):
+            raise NumbaValueError("%d dimensional neighborhood specified "
+                                  "for %d dimensional input array" %
+                                  (len(self.neighborhood), argtys[0].ndim))
+
+        argtys_extra = argtys
+        sig_extra = ""
+        result = None
+        if 'out' in kwtys:
+            argtys_extra += (kwtys['out'],)
+            sig_extra += ", out=None"
+            result = kwtys['out']
+
+        if 'neighborhood' in kwtys:
+            argtys_extra += (kwtys['neighborhood'],)
+            sig_extra += ", neighborhood=None"
+
+        # look in the type cache first
+        if argtys_extra in self._type_cache:
+            (_sig, _, _, _) = self._type_cache[argtys_extra]
+            return _sig
+
+        (real_ret, typemap, calltypes) = self.get_return_type(argtys)
+        sig = signature(real_ret, *argtys_extra)
+        dummy_text = ("def __numba_dummy_stencil({}{}):\n    pass\n".format(
+                        ",".join(self.kernel_ir.arg_names), sig_extra))
+        dct = {}
+        exec(dummy_text, dct)
+        dummy_func = dct["__numba_dummy_stencil"]
+        sig = sig.replace(pysig=utils.pysignature(dummy_func))
+        self._targetctx.insert_func_defn([(self._lower_me, self, argtys_extra)])
+        self._type_cache[argtys_extra] = (sig, result, typemap, calltypes)
+        return sig
+
+    def copy_ir_with_calltypes(self, ir, calltypes):
+        """
+        Create a copy of a given IR along with its calltype information.
+        We need a copy of the calltypes because copy propagation applied
+        to the copied IR will change the calltypes and make subsequent
+        uses of the original IR invalid.
+        """
+        copy_calltypes = {}
+        kernel_copy = ir.copy()
+        kernel_copy.blocks = {}
+        # For each block...
+        for (block_label, block) in ir.blocks.items():
+            new_block = copy.deepcopy(ir.blocks[block_label])
+            new_block.body = []
+            # For each statement in each block...
+            for stmt in ir.blocks[block_label].body:
+                # Copy the statement to the new copy of the kernel
+                # and if the original statement is in the original
+                # calltypes then add the type associated with this
+                # statement to the calltypes copy.
+                scopy = copy.deepcopy(stmt)
+                new_block.body.append(scopy)
+                if stmt in calltypes:
+                    copy_calltypes[scopy] = calltypes[stmt]
+            kernel_copy.blocks[block_label] = new_block
+        return (kernel_copy, copy_calltypes)
+
+    def _stencil_wrapper(self, result, sigret, return_type, typemap, calltypes, *args):
+        # Overall approach:
+        # 1) Construct a string containing a function definition for the stencil function
+        #    that will execute the stencil kernel.  This function definition includes a
+        #    unique stencil function name, the parameters to the stencil kernel, loop
+        #    nests across the dimensions of the input array.  Those loop nests use the
+        #    computed stencil kernel size so as not to try to compute elements where
+        #    elements outside the bounds of the input array would be needed.
+        # 2) The but of the loop nest in this new function is a special sentinel
+        #    assignment.
+        # 3) Get the IR of this new function.
+        # 4) Split the block containing the sentinel assignment and remove the sentinel
+        #    assignment.  Insert the stencil kernel IR into the stencil function IR
+        #    after label and variable renaming of the stencil kernel IR to prevent
+        #    conflicts with the stencil function IR.
+        # 5) Compile the combined stencil function IR + stencil kernel IR into existence.
+
+        # Copy the kernel so that our changes for this callsite
+        # won't effect other callsites.
+        (kernel_copy, copy_calltypes) = self.copy_ir_with_calltypes(
+                                            self.kernel_ir, calltypes)
+        # The stencil kernel body becomes the body of a loop, for which args aren't needed.
+        ir_utils.remove_args(kernel_copy.blocks)
+        first_arg = kernel_copy.arg_names[0]
+
+        in_cps, out_cps = ir_utils.copy_propagate(kernel_copy.blocks, typemap)
+        name_var_table = ir_utils.get_name_var_table(kernel_copy.blocks)
+        ir_utils.apply_copy_propagate(
+            kernel_copy.blocks,
+            in_cps,
+            name_var_table,
+            typemap,
+            copy_calltypes)
+
+        if "out" in name_var_table:
+            raise NumbaValueError("Cannot use the reserved word 'out' in stencil kernels.")
+
+        sentinel_name = ir_utils.get_unused_var_name("__sentinel__", name_var_table)
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("name_var_table", name_var_table, sentinel_name)
+
+        the_array = args[0]
+
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("_stencil_wrapper", return_type, return_type.dtype,
+                                      type(return_type.dtype), args)
+            ir_utils.dump_blocks(kernel_copy.blocks)
+
+        # We generate a Numba function to execute this stencil and here
+        # create the unique name of this function.
+        stencil_func_name = "__numba_stencil_%s_%s" % (
+                                        hex(id(the_array)).replace("-", "_"),
+                                        self.id)
+
+        # We will put a loop nest in the generated function for each
+        # dimension in the input array.  Here we create the name for
+        # the index variable for each dimension.  index0, index1, ...
+        index_vars = []
+        for i in range(the_array.ndim):
+            index_var_name = ir_utils.get_unused_var_name("index" + str(i),
+                                                          name_var_table)
+            index_vars += [index_var_name]
+
+        # Create extra signature for out and neighborhood.
+        out_name = ir_utils.get_unused_var_name("out", name_var_table)
+        neighborhood_name = ir_utils.get_unused_var_name("neighborhood",
+                                                         name_var_table)
+        sig_extra = ""
+        if result is not None:
+            sig_extra += ", {}=None".format(out_name)
+        if "neighborhood" in dict(self.kws):
+            sig_extra += ", {}=None".format(neighborhood_name)
+
+        # Get a list of the standard indexed array names.
+        standard_indexed = self.options.get("standard_indexing", [])
+
+        if first_arg in standard_indexed:
+            raise NumbaValueError("The first argument to a stencil kernel must "
+                                  "use relative indexing, not standard indexing.")
+
+        if len(set(standard_indexed) - set(kernel_copy.arg_names)) != 0:
+            raise NumbaValueError("Standard indexing requested for an array name "
+                                  "not present in the stencil kernel definition.")
+
+        # Add index variables to getitems in the IR to transition the accesses
+        # in the kernel from relative to regular Python indexing.  Returns the
+        # computed size of the stencil kernel and a list of the relatively indexed
+        # arrays.
+        kernel_size, relatively_indexed = self.add_indices_to_kernel(
+                kernel_copy, index_vars, the_array.ndim,
+                self.neighborhood, standard_indexed, typemap, copy_calltypes)
+        if self.neighborhood is None:
+            self.neighborhood = kernel_size
+
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("After add_indices_to_kernel")
+            ir_utils.dump_blocks(kernel_copy.blocks)
+
+        # The return in the stencil kernel becomes a setitem for that
+        # particular point in the iteration space.
+        ret_blocks = self.replace_return_with_setitem(kernel_copy.blocks,
+                                                      index_vars, out_name)
+
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("After replace_return_with_setitem", ret_blocks)
+            ir_utils.dump_blocks(kernel_copy.blocks)
+
+        # Start to form the new function to execute the stencil kernel.
+        func_text = "def {}({}{}):\n".format(stencil_func_name,
+                        ",".join(kernel_copy.arg_names), sig_extra)
+
+        # Get loop ranges for each dimension, which could be either int
+        # or variable. In the latter case we'll use the extra neighborhood
+        # argument to the function.
+        ranges = []
+        for i in range(the_array.ndim):
+            if isinstance(kernel_size[i][0], int):
+                lo = kernel_size[i][0]
+                hi = kernel_size[i][1]
+            else:
+                lo = "{}[{}][0]".format(neighborhood_name, i)
+                hi = "{}[{}][1]".format(neighborhood_name, i)
+            ranges.append((lo, hi))
+
+        # If there are more than one relatively indexed arrays, add a call to
+        # a function that will raise an error if any of the relatively indexed
+        # arrays are of different size than the first input array.
+        if len(relatively_indexed) > 1:
+            func_text += "    raise_if_incompatible_array_sizes(" + first_arg
+            for other_array in relatively_indexed:
+                if other_array != first_arg:
+                    func_text += "," + other_array
+            func_text += ")\n"
+
+        # Get the shape of the first input array.
+        shape_name = ir_utils.get_unused_var_name("full_shape", name_var_table)
+        func_text += "    {} = {}.shape\n".format(shape_name, first_arg)
+
+        # Converts cval to a string constant
+        def cval_as_str(cval):
+            if not np.isfinite(cval):
+                # See if this is a string-repr numerical const, issue #7286
+                if np.isnan(cval):
+                    return "np.nan"
+                elif np.isinf(cval):
+                    if cval < 0:
+                        return "-np.inf"
+                    else:
+                        return "np.inf"
+            else:
+                return str(cval)
+
+        # If we have to allocate the output array (the out argument was not used)
+        # then us numpy.full if the user specified a cval stencil decorator option
+        # or np.zeros if they didn't to allocate the array.
+        if result is None:
+            return_type_name = numpy_support.as_dtype(
+                               return_type.dtype).type.__name__
+            out_init ="{} = np.empty({}, dtype=np.{})\n".format(
+                        out_name, shape_name, return_type_name)
+
+            if "cval" in self.options:
+                cval = self.options["cval"]
+                cval_ty = typing.typeof.typeof(cval)
+                if not self._typingctx.can_convert(cval_ty, return_type.dtype):
+                    msg = "cval type does not match stencil return type."
+                    raise NumbaValueError(msg)
+            else:
+                 cval = 0
+            func_text += "    " + out_init
+            for dim in range(the_array.ndim):
+                start_items = [":"] * the_array.ndim
+                end_items = [":"] * the_array.ndim
+                start_items[dim] = ":-{}".format(self.neighborhood[dim][0])
+                end_items[dim] = "-{}:".format(self.neighborhood[dim][1])
+                func_text += "    " + "{}[{}] = {}\n".format(out_name, ",".join(start_items), cval_as_str(cval))
+                func_text += "    " + "{}[{}] = {}\n".format(out_name, ",".join(end_items), cval_as_str(cval))
+        else: # result is present, if cval is set then use it
+            if "cval" in self.options:
+                cval = self.options["cval"]
+                cval_ty = typing.typeof.typeof(cval)
+                if not self._typingctx.can_convert(cval_ty, return_type.dtype):
+                    msg = "cval type does not match stencil return type."
+                    raise NumbaValueError(msg)
+                out_init = "{}[:] = {}\n".format(out_name, cval_as_str(cval))
+                func_text += "    " + out_init
+
+        offset = 1
+        # Add the loop nests to the new function.
+        for i in range(the_array.ndim):
+            for j in range(offset):
+                func_text += "    "
+            # ranges[i][0] is the minimum index used in the i'th dimension
+            # but minimum's greater than 0 don't preclude any entry in the array.
+            # So, take the minimum of 0 and the minimum index found in the kernel
+            # and this will be a negative number (potentially -0).  Then, we do
+            # unary - on that to get the positive offset in this dimension whose
+            # use is precluded.
+            # ranges[i][1] is the maximum of 0 and the observed maximum index
+            # in this dimension because negative maximums would not cause us to
+            # preclude any entry in the array from being used.
+            func_text += ("for {} in range(-min(0,{}),"
+                          "{}[{}]-max(0,{})):\n").format(
+                            index_vars[i],
+                            ranges[i][0],
+                            shape_name,
+                            i,
+                            ranges[i][1])
+            offset += 1
+
+        for j in range(offset):
+            func_text += "    "
+        # Put a sentinel in the code so we can locate it in the IR.  We will
+        # remove this sentinel assignment and replace it with the IR for the
+        # stencil kernel body.
+        func_text += "{} = 0\n".format(sentinel_name)
+        func_text += "    return {}\n".format(out_name)
+
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("new stencil func text")
+            print(func_text)
+
+        # Force the new stencil function into existence.
+        dct = {}
+        dct.update(globals())
+        exec(func_text, dct)
+        stencil_func = dct[stencil_func_name]
+        if sigret is not None:
+            pysig = utils.pysignature(stencil_func)
+            sigret.pysig = pysig
+        # Get the IR for the newly created stencil function.
+        from numba.core import compiler
+        stencil_ir = compiler.run_frontend(stencil_func)
+        ir_utils.remove_dels(stencil_ir.blocks)
+
+        # rename all variables in stencil_ir afresh
+        var_table = ir_utils.get_name_var_table(stencil_ir.blocks)
+        new_var_dict = {}
+        reserved_names = ([sentinel_name, out_name, neighborhood_name,
+                           shape_name] + kernel_copy.arg_names + index_vars)
+        for name, var in var_table.items():
+            if not name in reserved_names:
+                assert isinstance(var, ir.Var)
+                new_var = var.scope.redefine(var.name, var.loc)
+                new_var_dict[name] = new_var.name
+        ir_utils.replace_var_names(stencil_ir.blocks, new_var_dict)
+
+        stencil_stub_last_label = max(stencil_ir.blocks.keys()) + 1
+
+        # Shift labels in the kernel copy so they are guaranteed unique
+        # and don't conflict with any labels in the stencil_ir.
+        kernel_copy.blocks = ir_utils.add_offset_to_labels(
+                                kernel_copy.blocks, stencil_stub_last_label)
+        new_label = max(kernel_copy.blocks.keys()) + 1
+        # Adjust ret_blocks to account for addition of the offset.
+        ret_blocks = [x + stencil_stub_last_label for x in ret_blocks]
+
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("ret_blocks w/ offsets", ret_blocks, stencil_stub_last_label)
+            print("before replace sentinel stencil_ir")
+            ir_utils.dump_blocks(stencil_ir.blocks)
+            print("before replace sentinel kernel_copy")
+            ir_utils.dump_blocks(kernel_copy.blocks)
+
+        # Search all the block in the stencil outline for the sentinel.
+        for label, block in stencil_ir.blocks.items():
+            for i, inst in enumerate(block.body):
+                if (isinstance( inst, ir.Assign) and
+                    inst.target.name == sentinel_name):
+                    # We found the sentinel assignment.
+                    loc = inst.loc
+                    scope = block.scope
+                    # split block across __sentinel__
+                    # A new block is allocated for the statements prior to the
+                    # sentinel but the new block maintains the current block
+                    # label.
+                    prev_block = ir.Block(scope, loc)
+                    prev_block.body = block.body[:i]
+                    # The current block is used for statements after sentinel.
+                    block.body = block.body[i + 1:]
+                    # But the current block gets a new label.
+                    body_first_label = min(kernel_copy.blocks.keys())
+
+                    # The previous block jumps to the minimum labelled block of
+                    # the parfor body.
+                    prev_block.append(ir.Jump(body_first_label, loc))
+                    # Add all the parfor loop body blocks to the gufunc
+                    # function's IR.
+                    for (l, b) in kernel_copy.blocks.items():
+                        stencil_ir.blocks[l] = b
+
+                    stencil_ir.blocks[new_label] = block
+                    stencil_ir.blocks[label] = prev_block
+                    # Add a jump from all the blocks that previously contained
+                    # a return in the stencil kernel to the block
+                    # containing statements after the sentinel.
+                    for ret_block in ret_blocks:
+                        stencil_ir.blocks[ret_block].append(
+                            ir.Jump(new_label, loc))
+                    break
+            else:
+                continue
+            break
+
+        stencil_ir.blocks = ir_utils.rename_labels(stencil_ir.blocks)
+        ir_utils.remove_dels(stencil_ir.blocks)
+
+        assert(isinstance(the_array, types.Type))
+        array_types = args
+
+        new_stencil_param_types = list(array_types)
+
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("new_stencil_param_types", new_stencil_param_types)
+            ir_utils.dump_blocks(stencil_ir.blocks)
+
+        # Compile the combined stencil function with the replaced loop
+        # body in it.
+        ir_utils.fixup_var_define_in_scope(stencil_ir.blocks)
+        new_func = compiler.compile_ir(
+            self._typingctx,
+            self._targetctx,
+            stencil_ir,
+            new_stencil_param_types,
+            None,
+            compiler.DEFAULT_FLAGS,
+            {})
+        return new_func
+
+    def __call__(self, *args, **kwargs):
+        self._typingctx.refresh()
+        if (self.neighborhood is not None and
+            len(self.neighborhood) != args[0].ndim):
+            raise NumbaValueError("{} dimensional neighborhood specified for "
+                                  "{} dimensional input array".format(
+                                  len(self.neighborhood), args[0].ndim))
+
+        if 'out' in kwargs:
+            result = kwargs['out']
+            rdtype = result.dtype
+            rttype = numpy_support.from_dtype(rdtype)
+            result_type = types.npytypes.Array(rttype, result.ndim,
+                                               numpy_support.map_layout(result))
+            array_types = tuple([typing.typeof.typeof(x) for x in args])
+            array_types_full = tuple([typing.typeof.typeof(x) for x in args] +
+                                     [result_type])
+        else:
+            result = None
+            array_types = tuple([typing.typeof.typeof(x) for x in args])
+            array_types_full = array_types
+
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("__call__", array_types, args, kwargs)
+
+        (real_ret, typemap, calltypes) = self.get_return_type(array_types)
+        new_func = self._stencil_wrapper(result, None, real_ret, typemap,
+                                         calltypes, *array_types_full)
+
+        if result is None:
+            return new_func.entry_point(*args)
+        else:
+            return new_func.entry_point(*(args+(result,)))
+
+def stencil(func_or_mode='constant', **options):
+    # called on function without specifying mode style
+    if not isinstance(func_or_mode, str):
+        mode = 'constant'  # default style
+        func = func_or_mode
+    else:
+        mode = func_or_mode
+        func = None
+
+    for option in options:
+        if option not in ["cval", "standard_indexing", "neighborhood"]:
+            raise NumbaValueError("Unknown stencil option " + option)
+
+    wrapper = _stencil(mode, options)
+    if func is not None:
+        return wrapper(func)
+    return wrapper
+
+def _stencil(mode, options):
+    if mode != 'constant':
+        raise NumbaValueError("Unsupported mode style " + mode)
+
+    def decorated(func):
+        from numba.core import compiler
+        kernel_ir = compiler.run_frontend(func)
+        return StencilFunc(kernel_ir, mode, options)
+
+    return decorated
+
+@lower_builtin(stencil)
+def stencil_dummy_lower(context, builder, sig, args):
+    "lowering for dummy stencil calls"
+    return lir.Constant(lir.IntType(types.intp.bitwidth), 0)

.venv/lib/python3.11/site-packages/numba/stencils/stencilparfor.py

@@ -0,0 +1,957 @@
+#
+# Copyright (c) 2017 Intel Corporation
+# SPDX-License-Identifier: BSD-2-Clause
+#
+
+import numbers
+import copy
+import types as pytypes
+from operator import add
+import operator
+
+import numpy as np
+
+import numba.parfors.parfor
+from numba.core import types, ir, rewrites, config, ir_utils
+from numba.core.typing.templates import infer_global, AbstractTemplate
+from numba.core.typing import signature
+from numba.core import  utils, typing
+from numba.core.ir_utils import (get_call_table, mk_unique_var,
+                            compile_to_numba_ir, replace_arg_nodes, guard,
+                            find_callname, require, find_const, GuardException)
+from numba.core.errors import NumbaValueError
+from numba.core.utils import OPERATORS_TO_BUILTINS
+from numba.np import numpy_support
+
+
+def _compute_last_ind(dim_size, index_const):
+    if index_const > 0:
+        return dim_size - index_const
+    else:
+        return dim_size
+
+class StencilPass(object):
+    def __init__(self, func_ir, typemap, calltypes, array_analysis, typingctx,
+                 targetctx, flags):
+        self.func_ir = func_ir
+        self.typemap = typemap
+        self.calltypes = calltypes
+        self.array_analysis = array_analysis
+        self.typingctx = typingctx
+        self.targetctx = targetctx
+        self.flags = flags
+
+    def run(self):
+        """ Finds all calls to StencilFuncs in the IR and converts them to parfor.
+        """
+        from numba.stencils.stencil import StencilFunc
+
+        # Get all the calls in the function IR.
+        call_table, _ = get_call_table(self.func_ir.blocks)
+        stencil_calls = []
+        stencil_dict = {}
+        for call_varname, call_list in call_table.items():
+            for one_call in call_list:
+                if isinstance(one_call, StencilFunc):
+                    # Remember all calls to StencilFuncs.
+                    stencil_calls.append(call_varname)
+                    stencil_dict[call_varname] = one_call
+        if not stencil_calls:
+            return  # return early if no stencil calls found
+
+        # find and transform stencil calls
+        for label, block in self.func_ir.blocks.items():
+            for i, stmt in reversed(list(enumerate(block.body))):
+                # Found a call to a StencilFunc.
+                if (isinstance(stmt, ir.Assign)
+                        and isinstance(stmt.value, ir.Expr)
+                        and stmt.value.op == 'call'
+                        and stmt.value.func.name in stencil_calls):
+                    kws = dict(stmt.value.kws)
+                    # Create dictionary of input argument number to
+                    # the argument itself.
+                    input_dict = {i: stmt.value.args[i] for i in
+                                                    range(len(stmt.value.args))}
+                    in_args = stmt.value.args
+                    arg_typemap = tuple(self.typemap[i.name] for i in in_args)
+                    for arg_type in arg_typemap:
+                        if isinstance(arg_type, types.BaseTuple):
+                            raise NumbaValueError("Tuple parameters not " \
+                                                  "supported for stencil " \
+                                                  "kernels in parallel=True " \
+                                                  "mode.")
+
+                    out_arr = kws.get('out')
+
+                    # Get the StencilFunc object corresponding to this call.
+                    sf = stencil_dict[stmt.value.func.name]
+                    stencil_ir, rt, arg_to_arr_dict = get_stencil_ir(sf,
+                            self.typingctx, arg_typemap,
+                            block.scope, block.loc, input_dict,
+                            self.typemap, self.calltypes)
+                    index_offsets = sf.options.get('index_offsets', None)
+                    gen_nodes = self._mk_stencil_parfor(label, in_args, out_arr,
+                            stencil_ir, index_offsets, stmt.target, rt, sf,
+                            arg_to_arr_dict)
+                    block.body = block.body[:i] + gen_nodes + block.body[i+1:]
+                # Found a call to a stencil via numba.stencil().
+                elif (isinstance(stmt, ir.Assign)
+                        and isinstance(stmt.value, ir.Expr)
+                        and stmt.value.op == 'call'
+                        and guard(find_callname, self.func_ir, stmt.value)
+                                    == ('stencil', 'numba')):
+                    # remove dummy stencil() call
+                    stmt.value = ir.Const(0, stmt.loc)
+
+    def replace_return_with_setitem(self, blocks, exit_value_var,
+                                    parfor_body_exit_label):
+        """
+        Find return statements in the IR and replace them with a SetItem
+        call of the value "returned" by the kernel into the result array.
+        Returns the block labels that contained return statements.
+        """
+        for label, block in blocks.items():
+            scope = block.scope
+            loc = block.loc
+            new_body = []
+            for stmt in block.body:
+                if isinstance(stmt, ir.Return):
+                    # previous stmt should have been a cast
+                    prev_stmt = new_body.pop()
+                    assert (isinstance(prev_stmt, ir.Assign)
+                        and isinstance(prev_stmt.value, ir.Expr)
+                        and prev_stmt.value.op == 'cast')
+
+                    new_body.append(ir.Assign(prev_stmt.value.value, exit_value_var, loc))
+                    new_body.append(ir.Jump(parfor_body_exit_label, loc))
+                else:
+                    new_body.append(stmt)
+            block.body = new_body
+
+    def _mk_stencil_parfor(self, label, in_args, out_arr, stencil_ir,
+                           index_offsets, target, return_type, stencil_func,
+                           arg_to_arr_dict):
+        """ Converts a set of stencil kernel blocks to a parfor.
+        """
+        gen_nodes = []
+        stencil_blocks = stencil_ir.blocks
+
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("_mk_stencil_parfor", label, in_args, out_arr, index_offsets,
+                   return_type, stencil_func, stencil_blocks)
+            ir_utils.dump_blocks(stencil_blocks)
+
+        in_arr = in_args[0]
+        # run copy propagate to replace in_args copies (e.g. a = A)
+        in_arr_typ = self.typemap[in_arr.name]
+        in_cps, out_cps = ir_utils.copy_propagate(stencil_blocks, self.typemap)
+        name_var_table = ir_utils.get_name_var_table(stencil_blocks)
+
+        ir_utils.apply_copy_propagate(
+            stencil_blocks,
+            in_cps,
+            name_var_table,
+            self.typemap,
+            self.calltypes)
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("stencil_blocks after copy_propagate")
+            ir_utils.dump_blocks(stencil_blocks)
+        ir_utils.remove_dead(stencil_blocks, self.func_ir.arg_names, stencil_ir,
+                             self.typemap)
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("stencil_blocks after removing dead code")
+            ir_utils.dump_blocks(stencil_blocks)
+
+        # create parfor vars
+        ndims = self.typemap[in_arr.name].ndim
+        scope = in_arr.scope
+        loc = in_arr.loc
+        parfor_vars = []
+        for i in range(ndims):
+            parfor_var = ir.Var(scope, mk_unique_var(
+                "$parfor_index_var"), loc)
+            self.typemap[parfor_var.name] = types.intp
+            parfor_vars.append(parfor_var)
+
+        start_lengths, end_lengths = self._replace_stencil_accesses(
+             stencil_ir, parfor_vars, in_args, index_offsets, stencil_func,
+             arg_to_arr_dict)
+
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("stencil_blocks after replace stencil accesses")
+            print("start_lengths:", start_lengths)
+            print("end_lengths:", end_lengths)
+            ir_utils.dump_blocks(stencil_blocks)
+
+        # create parfor loop nests
+        loopnests = []
+        equiv_set = self.array_analysis.get_equiv_set(label)
+        in_arr_dim_sizes = equiv_set.get_shape(in_arr)
+
+        assert ndims == len(in_arr_dim_sizes)
+        start_inds = []
+        last_inds = []
+        for i in range(ndims):
+            last_ind = self._get_stencil_last_ind(in_arr_dim_sizes[i],
+                                        end_lengths[i], gen_nodes, scope, loc)
+            start_ind = self._get_stencil_start_ind(
+                                        start_lengths[i], gen_nodes, scope, loc)
+            start_inds.append(start_ind)
+            last_inds.append(last_ind)
+            # start from stencil size to avoid invalid array access
+            loopnests.append(numba.parfors.parfor.LoopNest(parfor_vars[i],
+                                start_ind, last_ind, 1))
+
+        # We have to guarantee that the exit block has maximum label and that
+        # there's only one exit block for the parfor body.
+        # So, all return statements will change to jump to the parfor exit block.
+        parfor_body_exit_label = max(stencil_blocks.keys()) + 1
+        stencil_blocks[parfor_body_exit_label] = ir.Block(scope, loc)
+        exit_value_var = ir.Var(scope, mk_unique_var("$parfor_exit_value"), loc)
+        self.typemap[exit_value_var.name] = return_type.dtype
+
+        # create parfor index var
+        for_replacing_ret = []
+        if ndims == 1:
+            parfor_ind_var = parfor_vars[0]
+        else:
+            parfor_ind_var = ir.Var(scope, mk_unique_var(
+                "$parfor_index_tuple_var"), loc)
+            self.typemap[parfor_ind_var.name] = types.containers.UniTuple(
+                types.intp, ndims)
+            tuple_call = ir.Expr.build_tuple(parfor_vars, loc)
+            tuple_assign = ir.Assign(tuple_call, parfor_ind_var, loc)
+            for_replacing_ret.append(tuple_assign)
+
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("stencil_blocks after creating parfor index var")
+            ir_utils.dump_blocks(stencil_blocks)
+
+        # empty init block
+        init_block = ir.Block(scope, loc)
+        if out_arr is None:
+            in_arr_typ = self.typemap[in_arr.name]
+
+            shape_name = ir_utils.mk_unique_var("in_arr_shape")
+            shape_var = ir.Var(scope, shape_name, loc)
+            shape_getattr = ir.Expr.getattr(in_arr, "shape", loc)
+            self.typemap[shape_name] = types.containers.UniTuple(types.intp,
+                                                               in_arr_typ.ndim)
+            init_block.body.extend([ir.Assign(shape_getattr, shape_var, loc)])
+
+            zero_name = ir_utils.mk_unique_var("zero_val")
+            zero_var = ir.Var(scope, zero_name, loc)
+            if "cval" in stencil_func.options:
+                cval = stencil_func.options["cval"]
+                # TODO: Loosen this restriction to adhere to casting rules.
+                cval_ty = typing.typeof.typeof(cval)
+                if not self.typingctx.can_convert(cval_ty, return_type.dtype):
+                    raise NumbaValueError("cval type does not match stencil " \
+                                          "return type.")
+
+                temp2 = return_type.dtype(cval)
+            else:
+                temp2 = return_type.dtype(0)
+            full_const = ir.Const(temp2, loc)
+            self.typemap[zero_name] = return_type.dtype
+            init_block.body.extend([ir.Assign(full_const, zero_var, loc)])
+
+            so_name = ir_utils.mk_unique_var("stencil_output")
+            out_arr = ir.Var(scope, so_name, loc)
+            self.typemap[out_arr.name] = numba.core.types.npytypes.Array(
+                                                           return_type.dtype,
+                                                           in_arr_typ.ndim,
+                                                           in_arr_typ.layout)
+            dtype_g_np_var = ir.Var(scope, mk_unique_var("$np_g_var"), loc)
+            self.typemap[dtype_g_np_var.name] = types.misc.Module(np)
+            dtype_g_np = ir.Global('np', np, loc)
+            dtype_g_np_assign = ir.Assign(dtype_g_np, dtype_g_np_var, loc)
+            init_block.body.append(dtype_g_np_assign)
+
+            return_type_name = numpy_support.as_dtype(
+                               return_type.dtype).type.__name__
+            if return_type_name == 'bool':
+                return_type_name = 'bool_'
+            dtype_np_attr_call = ir.Expr.getattr(dtype_g_np_var, return_type_name, loc)
+            dtype_attr_var = ir.Var(scope, mk_unique_var("$np_attr_attr"), loc)
+            self.typemap[dtype_attr_var.name] = types.functions.NumberClass(return_type.dtype)
+            dtype_attr_assign = ir.Assign(dtype_np_attr_call, dtype_attr_var, loc)
+            init_block.body.append(dtype_attr_assign)
+
+            stmts = ir_utils.gen_np_call("empty",
+                                       np.empty,
+                                       out_arr,
+                                       [shape_var, dtype_attr_var],
+                                       self.typingctx,
+                                       self.typemap,
+                                       self.calltypes)
+            # ------------------
+            # Generate the code to fill just the border with zero_var.
+
+            # Generate a none var to use in slicing.
+            none_var = ir.Var(scope, mk_unique_var("$none_var"), loc)
+            none_assign = ir.Assign(ir.Const(None, loc), none_var, loc)
+            stmts.append(none_assign)
+            self.typemap[none_var.name] = types.none
+            # Generate a zero var to use in slicing.
+            zero_index_var = ir.Var(scope, mk_unique_var("$zero_index_var"), loc)
+            zero_index_assign = ir.Assign(ir.Const(0, loc), zero_index_var, loc)
+            stmts.append(zero_index_assign)
+            self.typemap[zero_index_var.name] = types.intp
+            # Generate generic ":" slice.
+            # ---- Generate var to hold slice func var.
+            slice_func_var = ir.Var(scope, mk_unique_var("$slice_func_var"), loc)
+            slice_fn_ty = self.typingctx.resolve_value_type(slice)
+            self.typemap[slice_func_var.name] = slice_fn_ty
+            slice_g = ir.Global('slice', slice, loc)
+            slice_assign = ir.Assign(slice_g, slice_func_var, loc)
+            stmts.append(slice_assign)
+            # ---- Generate call to slice func.
+            sig = self.typingctx.resolve_function_type(slice_fn_ty,
+                                                       (types.none,) * 2,
+                                                       {})
+            slice_callexpr = ir.Expr.call(func=slice_func_var,
+                                          args=(none_var, none_var),
+                                          kws=(),
+                                          loc=loc)
+            self.calltypes[slice_callexpr] = sig
+            # ---- Generate slice var
+            slice_var = ir.Var(scope, mk_unique_var("$slice"), loc)
+            self.typemap[slice_var.name] = types.slice2_type
+            slice_assign = ir.Assign(slice_callexpr, slice_var, loc)
+            stmts.append(slice_assign)
+
+            def handle_border(slice_fn_ty,
+                              dim,
+                              scope,
+                              loc,
+                              slice_func_var,
+                              stmts,
+                              border_inds,
+                              border_tuple_items,
+                              other_arg,
+                              other_first):
+                # Handle the border for start or end of the index range.
+                # ---- Generate call to slice func.
+                sig = self.typingctx.resolve_function_type(
+                    slice_fn_ty,
+                    (types.intp,) * 2,
+                    {})
+                si = border_inds[dim]
+                assert(isinstance(si, (int, ir.Var)))
+                si_var = ir.Var(scope, mk_unique_var("$border_ind"), loc)
+                self.typemap[si_var.name] = types.intp
+                if isinstance(si, int):
+                    si_assign = ir.Assign(ir.Const(si, loc), si_var, loc)
+                else:
+                    si_assign = ir.Assign(si, si_var, loc)
+                stmts.append(si_assign)
+
+                slice_callexpr = ir.Expr.call(
+                    func=slice_func_var,
+                    args=(other_arg, si_var) if other_first else (si_var, other_arg),
+                    kws=(),
+                    loc=loc)
+                self.calltypes[slice_callexpr] = sig
+                # ---- Generate slice var
+                border_slice_var = ir.Var(scope, mk_unique_var("$slice"), loc)
+                self.typemap[border_slice_var.name] = types.slice2_type
+                slice_assign = ir.Assign(slice_callexpr, border_slice_var, loc)
+                stmts.append(slice_assign)
+
+                border_tuple_items[dim] = border_slice_var
+                border_ind_var = ir.Var(scope, mk_unique_var(
+                    "$border_index_tuple_var"), loc)
+                self.typemap[border_ind_var.name] = types.containers.UniTuple(
+                    types.slice2_type, ndims)
+                tuple_call = ir.Expr.build_tuple(border_tuple_items, loc)
+                tuple_assign = ir.Assign(tuple_call, border_ind_var, loc)
+                stmts.append(tuple_assign)
+
+                setitem_call = ir.SetItem(out_arr, border_ind_var, zero_var, loc)
+                self.calltypes[setitem_call] = signature(
+                                                types.none, self.typemap[out_arr.name],
+                                                self.typemap[border_ind_var.name],
+                                                self.typemap[out_arr.name].dtype
+                                                )
+                stmts.append(setitem_call)
+
+            # For each dimension, add setitem to set border values.
+            for dim in range(in_arr_typ.ndim):
+                # First, fill all entries with ":".
+                start_tuple_items = [slice_var] * in_arr_typ.ndim
+                last_tuple_items = [slice_var] * in_arr_typ.ndim
+
+                handle_border(slice_fn_ty,
+                              dim,
+                              scope,
+                              loc,
+                              slice_func_var,
+                              stmts,
+                              start_inds,
+                              start_tuple_items,
+                              zero_index_var,
+                              True)
+                handle_border(slice_fn_ty,
+                              dim,
+                              scope,
+                              loc,
+                              slice_func_var,
+                              stmts,
+                              last_inds,
+                              last_tuple_items,
+                              in_arr_dim_sizes[dim],
+                              False)
+
+            # ------------------
+
+            equiv_set.insert_equiv(out_arr, in_arr_dim_sizes)
+            init_block.body.extend(stmts)
+        else: # out is present
+            if "cval" in stencil_func.options: # do out[:] = cval
+                cval = stencil_func.options["cval"]
+                # TODO: Loosen this restriction to adhere to casting rules.
+                cval_ty = typing.typeof.typeof(cval)
+                if not self.typingctx.can_convert(cval_ty, return_type.dtype):
+                    msg = "cval type does not match stencil return type."
+                    raise NumbaValueError(msg)
+
+                # get slice ref
+                slice_var = ir.Var(scope, mk_unique_var("$py_g_var"), loc)
+                slice_fn_ty = self.typingctx.resolve_value_type(slice)
+                self.typemap[slice_var.name] = slice_fn_ty
+                slice_g = ir.Global('slice', slice, loc)
+                slice_assigned = ir.Assign(slice_g, slice_var, loc)
+                init_block.body.append(slice_assigned)
+
+                sig = self.typingctx.resolve_function_type(slice_fn_ty,
+                                                           (types.none,) * 2,
+                                                           {})
+
+                callexpr = ir.Expr.call(func=slice_var, args=(), kws=(),
+                                        loc=loc)
+
+                self.calltypes[callexpr] = sig
+                slice_inst_var = ir.Var(scope, mk_unique_var("$slice_inst"),
+                                        loc)
+                self.typemap[slice_inst_var.name] = types.slice2_type
+                slice_assign = ir.Assign(callexpr, slice_inst_var, loc)
+                init_block.body.append(slice_assign)
+
+                # get const val for cval
+                cval_const_val = ir.Const(return_type.dtype(cval), loc)
+                cval_const_var = ir.Var(scope, mk_unique_var("$cval_const"),
+                                            loc)
+                self.typemap[cval_const_var.name] = return_type.dtype
+                cval_const_assign = ir.Assign(cval_const_val,
+                                              cval_const_var, loc)
+                init_block.body.append(cval_const_assign)
+
+                # do setitem on `out` array
+                setitemexpr = ir.StaticSetItem(out_arr, slice(None, None),
+                                               slice_inst_var, cval_const_var,
+                                               loc)
+                init_block.body.append(setitemexpr)
+                sig = signature(types.none, self.typemap[out_arr.name],
+                                self.typemap[slice_inst_var.name],
+                                self.typemap[out_arr.name].dtype)
+                self.calltypes[setitemexpr] = sig
+
+
+        self.replace_return_with_setitem(stencil_blocks, exit_value_var,
+                                         parfor_body_exit_label)
+
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("stencil_blocks after replacing return")
+            ir_utils.dump_blocks(stencil_blocks)
+
+        setitem_call = ir.SetItem(out_arr, parfor_ind_var, exit_value_var, loc)
+        self.calltypes[setitem_call] = signature(
+                                        types.none, self.typemap[out_arr.name],
+                                        self.typemap[parfor_ind_var.name],
+                                        self.typemap[out_arr.name].dtype
+                                        )
+        stencil_blocks[parfor_body_exit_label].body.extend(for_replacing_ret)
+        stencil_blocks[parfor_body_exit_label].body.append(setitem_call)
+
+        # simplify CFG of parfor body (exit block could be simplified often)
+        # add dummy return to enable CFG
+        dummy_loc = ir.Loc("stencilparfor_dummy", -1)
+        ret_const_var = ir.Var(scope, mk_unique_var("$cval_const"), dummy_loc)
+        cval_const_assign = ir.Assign(ir.Const(0, loc=dummy_loc), ret_const_var, dummy_loc)
+        stencil_blocks[parfor_body_exit_label].body.append(cval_const_assign)
+
+        stencil_blocks[parfor_body_exit_label].body.append(
+            ir.Return(ret_const_var, dummy_loc),
+        )
+        stencil_blocks = ir_utils.simplify_CFG(stencil_blocks)
+        stencil_blocks[max(stencil_blocks.keys())].body.pop()
+
+        if config.DEBUG_ARRAY_OPT >= 1:
+            print("stencil_blocks after adding SetItem")
+            ir_utils.dump_blocks(stencil_blocks)
+
+        pattern = ('stencil', [start_lengths, end_lengths])
+        parfor = numba.parfors.parfor.Parfor(loopnests, init_block, stencil_blocks,
+                                     loc, parfor_ind_var, equiv_set, pattern, self.flags)
+        gen_nodes.append(parfor)
+        gen_nodes.append(ir.Assign(out_arr, target, loc))
+        return gen_nodes
+
+    def _get_stencil_last_ind(self, dim_size, end_length, gen_nodes, scope,
+                                                                        loc):
+        last_ind = dim_size
+        if end_length != 0:
+            # set last index to size minus stencil size to avoid invalid
+            # memory access
+            index_const = ir.Var(scope, mk_unique_var("stencil_const_var"),
+                                                                        loc)
+            self.typemap[index_const.name] = types.intp
+            if isinstance(end_length, numbers.Number):
+                const_assign = ir.Assign(ir.Const(end_length, loc),
+                                                        index_const, loc)
+            else:
+                const_assign = ir.Assign(end_length, index_const, loc)
+
+            gen_nodes.append(const_assign)
+            last_ind = ir.Var(scope, mk_unique_var("last_ind"), loc)
+            self.typemap[last_ind.name] = types.intp
+
+            g_var = ir.Var(scope, mk_unique_var("compute_last_ind_var"), loc)
+            check_func = numba.njit(_compute_last_ind)
+            func_typ = types.functions.Dispatcher(check_func)
+            self.typemap[g_var.name] = func_typ
+            g_obj = ir.Global("_compute_last_ind", check_func, loc)
+            g_assign = ir.Assign(g_obj, g_var, loc)
+            gen_nodes.append(g_assign)
+            index_call = ir.Expr.call(g_var, [dim_size, index_const], (), loc)
+            self.calltypes[index_call] = func_typ.get_call_type(
+                self.typingctx, [types.intp, types.intp], {})
+            index_assign = ir.Assign(index_call, last_ind, loc)
+            gen_nodes.append(index_assign)
+
+        return last_ind
+
+    def _get_stencil_start_ind(self, start_length, gen_nodes, scope, loc):
+        if isinstance(start_length, int):
+            return abs(min(start_length, 0))
+        def get_start_ind(s_length):
+            return abs(min(s_length, 0))
+        f_ir = compile_to_numba_ir(get_start_ind, {}, self.typingctx,
+                                   self.targetctx, (types.intp,), self.typemap,
+                                   self.calltypes)
+        assert len(f_ir.blocks) == 1
+        block = f_ir.blocks.popitem()[1]
+        replace_arg_nodes(block, [start_length])
+        gen_nodes += block.body[:-2]
+        ret_var = block.body[-2].value.value
+        return ret_var
+
+    def _replace_stencil_accesses(self, stencil_ir, parfor_vars, in_args,
+                                  index_offsets, stencil_func, arg_to_arr_dict):
+        """ Convert relative indexing in the stencil kernel to standard indexing
+            by adding the loop index variables to the corresponding dimensions
+            of the array index tuples.
+        """
+        stencil_blocks = stencil_ir.blocks
+        in_arr = in_args[0]
+        in_arg_names = [x.name for x in in_args]
+
+        if "standard_indexing" in stencil_func.options:
+            for x in stencil_func.options["standard_indexing"]:
+                if x not in arg_to_arr_dict:
+                    raise NumbaValueError("Standard indexing requested for " \
+                                          "an array name not present in the " \
+                                          "stencil kernel definition.")
+            standard_indexed = [arg_to_arr_dict[x] for x in
+                                     stencil_func.options["standard_indexing"]]
+        else:
+            standard_indexed = []
+
+        if in_arr.name in standard_indexed:
+            raise NumbaValueError("The first argument to a stencil kernel " \
+                                  "must use relative indexing, not standard " \
+                                  "indexing.")
+
+        ndims = self.typemap[in_arr.name].ndim
+        scope = in_arr.scope
+        loc = in_arr.loc
+        # replace access indices, find access lengths in each dimension
+        need_to_calc_kernel = stencil_func.neighborhood is None
+
+        # If we need to infer the kernel size then initialize the minimum and
+        # maximum seen indices for each dimension to 0.  If we already have
+        # the neighborhood calculated then just convert from neighborhood format
+        # to the separate start and end lengths format used here.
+        if need_to_calc_kernel:
+            start_lengths = ndims*[0]
+            end_lengths = ndims*[0]
+        else:
+            start_lengths = [x[0] for x in stencil_func.neighborhood]
+            end_lengths   = [x[1] for x in stencil_func.neighborhood]
+
+        # Get all the tuples defined in the stencil blocks.
+        tuple_table = ir_utils.get_tuple_table(stencil_blocks)
+
+        found_relative_index = False
+
+        # For all blocks in the stencil kernel...
+        for label, block in stencil_blocks.items():
+            new_body = []
+            # For all statements in those blocks...
+            for stmt in block.body:
+                # Reject assignments to input arrays.
+                if ((isinstance(stmt, ir.Assign)
+                        and isinstance(stmt.value, ir.Expr)
+                        and stmt.value.op in ['setitem', 'static_setitem']
+                        and stmt.value.value.name in in_arg_names) or
+                   ((isinstance(stmt, ir.SetItem) or
+                     isinstance(stmt, ir.StaticSetItem))
+                        and stmt.target.name in in_arg_names)):
+                    raise NumbaValueError("Assignments to arrays passed to " \
+                                          "stencil kernels is not allowed.")
+                # We found a getitem for some array.  If that array is an input
+                # array and isn't in the list of standard indexed arrays then
+                # update min and max seen indices if we are inferring the
+                # kernel size and create a new tuple where the relative offsets
+                # are added to loop index vars to get standard indexing.
+                if (isinstance(stmt, ir.Assign)
+                        and isinstance(stmt.value, ir.Expr)
+                        and stmt.value.op in ['static_getitem', 'getitem']
+                        and stmt.value.value.name in in_arg_names
+                        and stmt.value.value.name not in standard_indexed):
+                    index_list = stmt.value.index
+                    # handle 1D case
+                    if ndims == 1:
+                        index_list = [index_list]
+                    else:
+                        if hasattr(index_list, 'name') and index_list.name in tuple_table:
+                            index_list = tuple_table[index_list.name]
+                    # indices can be inferred as constant in simple expressions
+                    # like -c where c is constant
+                    # handled here since this is a common stencil index pattern
+                    stencil_ir._definitions = ir_utils.build_definitions(stencil_blocks)
+                    index_list = [_get_const_index_expr(
+                        stencil_ir, self.func_ir, v) for v in index_list]
+                    if index_offsets:
+                        index_list = self._add_index_offsets(index_list,
+                                    list(index_offsets), new_body, scope, loc)
+
+                    # update min and max indices
+                    if need_to_calc_kernel:
+                        # all indices should be integer to be able to calculate
+                        # neighborhood automatically
+                        if (isinstance(index_list, ir.Var) or
+                            any([not isinstance(v, int) for v in index_list])):
+                            raise NumbaValueError("Variable stencil index " \
+                                                  "only possible with known " \
+                                                  "neighborhood")
+                        start_lengths = list(map(min, start_lengths,
+                                                                    index_list))
+                        end_lengths = list(map(max, end_lengths, index_list))
+                        found_relative_index = True
+
+                    # update access indices
+                    index_vars = self._add_index_offsets(parfor_vars,
+                                list(index_list), new_body, scope, loc)
+
+                    # new access index tuple
+                    if ndims == 1:
+                        ind_var = index_vars[0]
+                    else:
+                        ind_var = ir.Var(scope, mk_unique_var(
+                            "$parfor_index_ind_var"), loc)
+                        self.typemap[ind_var.name] = types.containers.UniTuple(
+                            types.intp, ndims)
+                        tuple_call = ir.Expr.build_tuple(index_vars, loc)
+                        tuple_assign = ir.Assign(tuple_call, ind_var, loc)
+                        new_body.append(tuple_assign)
+
+                    # getitem return type is scalar if all indices are integer
+                    if all([self.typemap[v.name] == types.intp
+                                                        for v in index_vars]):
+                        getitem_return_typ = self.typemap[
+                                                    stmt.value.value.name].dtype
+                    else:
+                        # getitem returns an array
+                        getitem_return_typ = self.typemap[stmt.value.value.name]
+                    # new getitem with the new index var
+                    getitem_call = ir.Expr.getitem(stmt.value.value, ind_var,
+                                                                            loc)
+                    self.calltypes[getitem_call] = signature(
+                        getitem_return_typ,
+                        self.typemap[stmt.value.value.name],
+                        self.typemap[ind_var.name])
+                    stmt.value = getitem_call
+
+                new_body.append(stmt)
+            block.body = new_body
+        if need_to_calc_kernel and not found_relative_index:
+            raise NumbaValueError("Stencil kernel with no accesses to " \
+                                  "relatively indexed arrays.")
+
+        return start_lengths, end_lengths
+
+    def _add_index_offsets(self, index_list, index_offsets, new_body,
+                           scope, loc):
+        """ Does the actual work of adding loop index variables to the
+            relative index constants or variables.
+        """
+        assert len(index_list) == len(index_offsets)
+
+        # shortcut if all values are integer
+        if all([isinstance(v, int) for v in index_list+index_offsets]):
+            # add offsets in all dimensions
+            return list(map(add, index_list, index_offsets))
+
+        out_nodes = []
+        index_vars = []
+        for i in range(len(index_list)):
+            # new_index = old_index + offset
+            old_index_var = index_list[i]
+            if isinstance(old_index_var, int):
+                old_index_var = ir.Var(scope,
+                                mk_unique_var("old_index_var"), loc)
+                self.typemap[old_index_var.name] = types.intp
+                const_assign = ir.Assign(ir.Const(index_list[i], loc),
+                                                    old_index_var, loc)
+                out_nodes.append(const_assign)
+
+            offset_var = index_offsets[i]
+            if isinstance(offset_var, int):
+                offset_var = ir.Var(scope,
+                                mk_unique_var("offset_var"), loc)
+                self.typemap[offset_var.name] = types.intp
+                const_assign = ir.Assign(ir.Const(index_offsets[i], loc),
+                                                offset_var, loc)
+                out_nodes.append(const_assign)
+
+            if (isinstance(old_index_var, slice)
+                    or isinstance(self.typemap[old_index_var.name],
+                                    types.misc.SliceType)):
+                # only one arg can be slice
+                assert self.typemap[offset_var.name] == types.intp
+                index_var = self._add_offset_to_slice(old_index_var, offset_var,
+                                                        out_nodes, scope, loc)
+                index_vars.append(index_var)
+                continue
+
+            if (isinstance(offset_var, slice)
+                    or isinstance(self.typemap[offset_var.name],
+                                    types.misc.SliceType)):
+                # only one arg can be slice
+                assert self.typemap[old_index_var.name] == types.intp
+                index_var = self._add_offset_to_slice(offset_var, old_index_var,
+                                                        out_nodes, scope, loc)
+                index_vars.append(index_var)
+                continue
+
+            index_var = ir.Var(scope,
+                            mk_unique_var("offset_stencil_index"), loc)
+            self.typemap[index_var.name] = types.intp
+            index_call = ir.Expr.binop(operator.add, old_index_var,
+                                                offset_var, loc)
+            self.calltypes[index_call] = self.typingctx.resolve_function_type(
+                                         operator.add, (types.intp, types.intp), {})
+            index_assign = ir.Assign(index_call, index_var, loc)
+            out_nodes.append(index_assign)
+            index_vars.append(index_var)
+
+        new_body.extend(out_nodes)
+        return index_vars
+
+    def _add_offset_to_slice(self, slice_var, offset_var, out_nodes, scope,
+                                loc):
+        if isinstance(slice_var, slice):
+            f_text = """def f(offset):
+                return slice({} + offset, {} + offset)
+            """.format(slice_var.start, slice_var.stop)
+            loc = {}
+            exec(f_text, {}, loc)
+            f = loc['f']
+            args = [offset_var]
+            arg_typs = (types.intp,)
+        else:
+            def f(old_slice, offset):
+                return slice(old_slice.start + offset, old_slice.stop + offset)
+            args = [slice_var, offset_var]
+            slice_type = self.typemap[slice_var.name]
+            arg_typs = (slice_type, types.intp,)
+        _globals = self.func_ir.func_id.func.__globals__
+        f_ir = compile_to_numba_ir(f, _globals, self.typingctx, self.targetctx,
+                                   arg_typs, self.typemap, self.calltypes)
+        _, block = f_ir.blocks.popitem()
+        replace_arg_nodes(block, args)
+        new_index = block.body[-2].value.value
+        out_nodes.extend(block.body[:-2])  # ignore return nodes
+        return new_index
+
+def get_stencil_ir(sf, typingctx, args, scope, loc, input_dict, typemap,
+                                                                    calltypes):
+    """get typed IR from stencil bytecode
+    """
+    from numba.core.cpu import CPUContext
+    from numba.core.registry import cpu_target
+    from numba.core.annotations import type_annotations
+    from numba.core.typed_passes import type_inference_stage
+
+    # get untyped IR
+    stencil_func_ir = sf.kernel_ir.copy()
+    # copy the IR nodes to avoid changing IR in the StencilFunc object
+    stencil_blocks = copy.deepcopy(stencil_func_ir.blocks)
+    stencil_func_ir.blocks = stencil_blocks
+
+    name_var_table = ir_utils.get_name_var_table(stencil_func_ir.blocks)
+    if "out" in name_var_table:
+        raise NumbaValueError("Cannot use the reserved word 'out' in stencil " \
+                              "kernels.")
+
+    # get typed IR with a dummy pipeline (similar to test_parfors.py)
+    from numba.core.registry import cpu_target
+    targetctx = cpu_target.target_context
+
+    tp = DummyPipeline(typingctx, targetctx, args, stencil_func_ir)
+
+    rewrites.rewrite_registry.apply('before-inference', tp.state)
+
+    tp.state.typemap, tp.state.return_type, tp.state.calltypes, _ = type_inference_stage(
+        tp.state.typingctx, tp.state.targetctx, tp.state.func_ir,
+        tp.state.args, None)
+
+    type_annotations.TypeAnnotation(
+        func_ir=tp.state.func_ir,
+        typemap=tp.state.typemap,
+        calltypes=tp.state.calltypes,
+        lifted=(),
+        lifted_from=None,
+        args=tp.state.args,
+        return_type=tp.state.return_type,
+        html_output=config.HTML)
+
+    # make block labels unique
+    stencil_blocks = ir_utils.add_offset_to_labels(stencil_blocks,
+                                                        ir_utils.next_label())
+    min_label = min(stencil_blocks.keys())
+    max_label = max(stencil_blocks.keys())
+    ir_utils._the_max_label.update(max_label)
+
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("Initial stencil_blocks")
+        ir_utils.dump_blocks(stencil_blocks)
+
+    # rename variables,
+    var_dict = {}
+    for v, typ in tp.state.typemap.items():
+        new_var = ir.Var(scope, mk_unique_var(v), loc)
+        var_dict[v] = new_var
+        typemap[new_var.name] = typ  # add new var type for overall function
+    ir_utils.replace_vars(stencil_blocks, var_dict)
+
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("After replace_vars")
+        ir_utils.dump_blocks(stencil_blocks)
+
+    # add call types to overall function
+    for call, call_typ in tp.state.calltypes.items():
+        calltypes[call] = call_typ
+
+    arg_to_arr_dict = {}
+    # replace arg with arr
+    for block in stencil_blocks.values():
+        for stmt in block.body:
+            if isinstance(stmt, ir.Assign) and isinstance(stmt.value, ir.Arg):
+                if config.DEBUG_ARRAY_OPT >= 1:
+                    print("input_dict", input_dict, stmt.value.index,
+                               stmt.value.name, stmt.value.index in input_dict)
+                arg_to_arr_dict[stmt.value.name] = input_dict[stmt.value.index].name
+                stmt.value = input_dict[stmt.value.index]
+
+    if config.DEBUG_ARRAY_OPT >= 1:
+        print("arg_to_arr_dict", arg_to_arr_dict)
+        print("After replace arg with arr")
+        ir_utils.dump_blocks(stencil_blocks)
+
+    ir_utils.remove_dels(stencil_blocks)
+    stencil_func_ir.blocks = stencil_blocks
+    return stencil_func_ir, sf.get_return_type(args)[0], arg_to_arr_dict
+
+class DummyPipeline(object):
+    def __init__(self, typingctx, targetctx, args, f_ir):
+        from numba.core.compiler import StateDict
+        self.state = StateDict()
+        self.state.typingctx = typingctx
+        self.state.targetctx = targetctx
+        self.state.args = args
+        self.state.func_ir = f_ir
+        self.state.typemap = None
+        self.state.return_type = None
+        self.state.calltypes = None
+
+
+def _get_const_index_expr(stencil_ir, func_ir, index_var):
+    """
+    infer index_var as constant if it is of a expression form like c-1 where c
+    is a constant in the outer function.
+    index_var is assumed to be inside stencil kernel
+    """
+    const_val = guard(
+        _get_const_index_expr_inner, stencil_ir, func_ir, index_var)
+    if const_val is not None:
+        return const_val
+    return index_var
+
+def _get_const_index_expr_inner(stencil_ir, func_ir, index_var):
+    """inner constant inference function that calls constant, unary and binary
+    cases.
+    """
+    require(isinstance(index_var, ir.Var))
+    # case where the index is a const itself in outer function
+    var_const =  guard(_get_const_two_irs, stencil_ir, func_ir, index_var)
+    if var_const is not None:
+        return var_const
+    # get index definition
+    index_def = ir_utils.get_definition(stencil_ir, index_var)
+    # match inner_var = unary(index_var)
+    var_const = guard(
+        _get_const_unary_expr, stencil_ir, func_ir, index_def)
+    if var_const is not None:
+        return var_const
+    # match inner_var = arg1 + arg2
+    var_const = guard(
+        _get_const_binary_expr, stencil_ir, func_ir, index_def)
+    if var_const is not None:
+        return var_const
+    raise GuardException
+
+def _get_const_two_irs(ir1, ir2, var):
+    """get constant in either of two IRs if available
+    otherwise, throw GuardException
+    """
+    var_const = guard(find_const, ir1, var)
+    if var_const is not None:
+        return var_const
+    var_const = guard(find_const, ir2, var)
+    if var_const is not None:
+        return var_const
+    raise GuardException
+
+def _get_const_unary_expr(stencil_ir, func_ir, index_def):
+    """evaluate constant unary expr if possible
+    otherwise, raise GuardException
+    """
+    require(isinstance(index_def, ir.Expr) and index_def.op == 'unary')
+    inner_var = index_def.value
+    # return -c as constant
+    const_val = _get_const_index_expr_inner(stencil_ir, func_ir, inner_var)
+    op = OPERATORS_TO_BUILTINS[index_def.fn]
+    return eval("{}{}".format(op, const_val))
+
+def _get_const_binary_expr(stencil_ir, func_ir, index_def):
+    """evaluate constant binary expr if possible
+    otherwise, raise GuardException
+    """
+    require(isinstance(index_def, ir.Expr) and index_def.op == 'binop')
+    arg1 = _get_const_index_expr_inner(stencil_ir, func_ir, index_def.lhs)
+    arg2 = _get_const_index_expr_inner(stencil_ir, func_ir, index_def.rhs)
+    op = OPERATORS_TO_BUILTINS[index_def.fn]
+    return eval("{}{}{}".format(arg1, op, arg2))

.venv/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

.venv/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)

.venv/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

.venv/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

.venv/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.66 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.66...HEAD'
+    else:
+        target = 'origin/release0.66..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)

.venv/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")
+
+

.venv/lib/python3.11/site-packages/numba/tests/__init__.py

@@ -0,0 +1,33 @@
+import gc
+from os.path import dirname, join
+import multiprocessing
+import sys
+import time
+import unittest
+import warnings
+
+from unittest.suite import TestSuite
+from numba.testing import load_testsuite
+
+
+try:
+    import faulthandler
+except ImportError:
+    faulthandler = None
+else:
+    try:
+        # May fail in IPython Notebook with UnsupportedOperation
+        faulthandler.enable()
+    except Exception as e:
+        msg = "Failed to enable faulthandler due to:\n{err}"
+        warnings.warn(msg.format(err=e))
+
+def load_tests(loader, tests, pattern):
+    suite = TestSuite()
+    suite.addTests(load_testsuite(loader, dirname(__file__)))
+    # Numba CUDA tests are located in a separate directory:
+    cuda_dir = join(dirname(dirname(__file__)), 'cuda/tests')
+    suite.addTests(loader.discover(cuda_dir))
+
+    return suite
+

.venv/lib/python3.11/site-packages/numba/tests/annotation_usecases.py

@@ -0,0 +1,16 @@
+"""
+Usecases with Python 3 function annotations.  This is a separate module
+in order to avoid syntax errors with Python 2.
+"""
+
+
+class AnnotatedClass:
+    """
+    A class with annotated methods.
+    """
+
+    def __init__(self, v: int):
+        self.x = v
+
+    def add(self, v: int) -> int:
+        return self.x + v

.venv/lib/python3.11/site-packages/numba/tests/cache_usecases.py

@@ -0,0 +1,172 @@
+"""
+This file will be copied to a temporary directory in order to
+exercise caching compiled Numba functions.
+
+See test_dispatcher.py.
+"""
+
+import sys
+
+import numpy as np
+
+from numba import jit, prange
+from numba.core import types
+
+from numba.tests.ctypes_usecases import c_sin
+from numba.tests.support import TestCase, captured_stderr
+
+
+@jit(cache=True, nopython=True)
+def simple_usecase(x):
+    return x
+
+def simple_usecase_caller(x):
+    return simple_usecase(x)
+
+
+@jit(cache=True, nopython=True)
+def add_usecase(x, y):
+    return x + y + Z
+
+
+@jit(cache=True, forceobj=True)
+def add_objmode_usecase(x, y):
+    object()
+    return x + y + Z
+
+
+@jit(nopython=True)
+def add_nocache_usecase(x, y):
+    return x + y + Z
+
+
+@jit(cache=True, nopython=True)
+def inner(x, y):
+    return x + y + Z
+
+@jit(cache=True, nopython=True)
+def outer(x, y):
+    return inner(-y, x)
+
+@jit(cache=False, nopython=True)
+def outer_uncached(x, y):
+    return inner(-y, x)
+
+
+@jit(cache=True, forceobj=True)
+def looplifted(n):
+    object()
+    res = 0
+    for i in range(n):
+        res = res + i
+    return res
+
+
+@jit(cache=True, nopython=True)
+def use_c_sin(x):
+    return c_sin(x)
+
+@jit(cache=True, nopython=True)
+def use_c_sin_nest1(x):
+    return use_c_sin(x)
+
+@jit(cache=True, nopython=True)
+def use_c_sin_nest2(x):
+    return use_c_sin_nest1(x)
+
+
+@jit(cache=True, nopython=True)
+def ambiguous_function(x):
+    return x + 2
+
+renamed_function1 = ambiguous_function
+
+@jit(cache=True, nopython=True)
+def ambiguous_function(x):
+    return x + 6
+
+renamed_function2 = ambiguous_function
+
+
+def make_closure(x):
+    @jit(cache=True, nopython=True)
+    def closure(y):
+        return x + y
+
+    return closure
+
+closure1 = make_closure(3)
+closure2 = make_closure(5)
+closure3 = make_closure(7)
+closure4 = make_closure(9)
+
+
+biggie = np.arange(10**6)
+
+@jit(cache=True, nopython=True)
+def use_big_array():
+    return biggie
+
+
+Z = 1
+
+# Exercise returning a record instance.  This used to hardcode the dtype
+# pointer's value in the bitcode.
+
+packed_record_type = np.dtype([('a', np.int8), ('b', np.float64)])
+aligned_record_type = np.dtype([('a', np.int8), ('b', np.float64)], align=True)
+
+packed_arr = np.empty(2, dtype=packed_record_type)
+for i in range(packed_arr.size):
+    packed_arr[i]['a'] = i + 1
+    packed_arr[i]['b'] = i + 42.5
+
+aligned_arr = np.array(packed_arr, dtype=aligned_record_type)
+
+@jit(cache=True, nopython=True)
+def record_return(ary, i):
+    return ary[i]
+
+
+class _TestModule(TestCase):
+    """
+    Tests for functionality of this module's functions.
+    Note this does not define any "test_*" method, instead check_module()
+    should be called by hand.
+    """
+
+    def check_module(self, mod):
+        self.assertPreciseEqual(mod.add_usecase(2, 3), 6)
+        self.assertPreciseEqual(mod.add_objmode_usecase(2, 3), 6)
+        self.assertPreciseEqual(mod.outer_uncached(3, 2), 2)
+        self.assertPreciseEqual(mod.outer(3, 2), 2)
+
+        packed_rec = mod.record_return(mod.packed_arr, 1)
+        self.assertPreciseEqual(tuple(packed_rec), (2, 43.5))
+        aligned_rec = mod.record_return(mod.aligned_arr, 1)
+        self.assertPreciseEqual(tuple(aligned_rec), (2, 43.5))
+
+
+@jit(cache=True)
+def first_class_function_mul(x):
+    return x * x
+
+
+@jit(cache=True)
+def first_class_function_add(x):
+    return x + x
+
+
+@jit(cache=True)
+def first_class_function_usecase(f, x):
+    return f(x)
+
+
+def self_test():
+    mod = sys.modules[__name__]
+    _TestModule().check_module(mod)
+
+
+@jit(parallel=True, cache=True, nopython=True)
+def parfor_usecase(ary):
+    return ary * ary + ary

.venv/lib/python3.11/site-packages/numba/tests/cffi_usecases.py

@@ -0,0 +1,197 @@
+import sys
+
+import numpy as np
+
+import numba.core.typing.cffi_utils as cffi_support
+from numba.tests.support import import_dynamic, temp_directory
+from numba.core.types import complex128
+
+
+def load_inline_module():
+    """
+    Create an inline module, return the corresponding ffi and dll objects.
+    """
+    from cffi import FFI
+
+    # We can't rely on libc availability on Windows anymore, so we use our
+    # own compiled wrappers (see https://bugs.python.org/issue23606).
+
+    defs = """
+    double _numba_test_sin(double x);
+    double _numba_test_cos(double x);
+    double _numba_test_funcptr(double (*func)(double));
+    bool _numba_test_boolean(void);
+    """
+
+    ffi = FFI()
+    ffi.cdef(defs)
+    # Load the _helperlib namespace
+    from numba import _helperlib
+    return ffi, ffi.dlopen(_helperlib.__file__)
+
+
+def load_ool_module():
+    """
+    Compile an out-of-line module, return the corresponding ffi and
+    module objects.
+    """
+    from cffi import FFI
+
+    numba_complex = """
+    typedef struct _numba_complex {
+        double real;
+        double imag;
+    } numba_complex;
+    """
+
+    bool_define = """
+    #ifdef _MSC_VER
+        #define false 0
+        #define true 1
+        #define bool int
+    #else
+        #include <stdbool.h>
+    #endif
+    """
+
+    defs = numba_complex + """
+    bool boolean(void);
+    double sin(double x);
+    double cos(double x);
+    int foo(int a, int b, int c);
+    void vsSin(int n, float* x, float* y);
+    void vdSin(int n, double* x, double* y);
+    void vector_real(numba_complex *c, double *real, int n);
+    void vector_imag(numba_complex *c, double *imag, int n);
+    """
+
+    source = numba_complex + bool_define + """
+    static bool boolean(void)
+    {
+        return true;
+    }
+
+    static int foo(int a, int b, int c)
+    {
+        return a + b * c;
+    }
+
+    void vsSin(int n, float* x, float* y) {
+        int i;
+        for (i=0; i<n; i++)
+            y[i] = sin(x[i]);
+    }
+
+    void vdSin(int n, double* x, double* y) {
+        int i;
+        for (i=0; i<n; i++)
+            y[i] = sin(x[i]);
+    }
+
+    static void vector_real(numba_complex *c, double *real, int n) {
+        int i;
+        for (i = 0; i < n; i++)
+            real[i] = c[i].real;
+    }
+
+    static void vector_imag(numba_complex *c, double *imag, int n) {
+        int i;
+        for (i = 0; i < n; i++)
+            imag[i] = c[i].imag;
+    }
+    """
+
+    ffi = FFI()
+    ffi.set_source('cffi_usecases_ool', source)
+    ffi.cdef(defs, override=True)
+    tmpdir = temp_directory('test_cffi')
+    ffi.compile(tmpdir=tmpdir)
+    sys.path.append(tmpdir)
+    try:
+        mod = import_dynamic('cffi_usecases_ool')
+        cffi_support.register_module(mod)
+        cffi_support.register_type(mod.ffi.typeof('struct _numba_complex'),
+                                   complex128)
+        return mod.ffi, mod
+    finally:
+        sys.path.remove(tmpdir)
+
+
+def init():
+    """
+    Initialize module globals.  This can invoke external utilities, hence not
+    being executed implicitly at module import.
+    """
+    global ffi, cffi_sin, cffi_cos, cffi_bool
+
+    if ffi is None:
+        ffi, dll = load_inline_module()
+        cffi_sin = dll._numba_test_sin
+        cffi_cos = dll._numba_test_cos
+        cffi_bool = dll._numba_test_boolean
+        del dll
+
+def init_ool():
+    """
+    Same as init() for OOL mode.
+    """
+    global ffi_ool, cffi_sin_ool, cffi_cos_ool, cffi_foo, cffi_bool_ool
+    global vsSin, vdSin, vector_real, vector_imag
+
+    if ffi_ool is None:
+        ffi_ool, mod = load_ool_module()
+        cffi_sin_ool = mod.lib.sin
+        cffi_cos_ool = mod.lib.cos
+        cffi_foo = mod.lib.foo
+        cffi_bool_ool = mod.lib.boolean
+        vsSin = mod.lib.vsSin
+        vdSin = mod.lib.vdSin
+        vector_real = mod.lib.vector_real
+        vector_imag = mod.lib.vector_imag
+        del mod
+
+ffi = ffi_ool = None
+
+
+def use_cffi_sin(x):
+    return cffi_sin(x) * 2
+
+def use_two_funcs(x):
+    return cffi_sin(x) - cffi_cos(x)
+
+def use_cffi_sin_ool(x):
+    return cffi_sin_ool(x) * 2
+
+def use_cffi_boolean_true():
+    return cffi_bool_ool()
+
+def use_two_funcs_ool(x):
+    return cffi_sin_ool(x) - cffi_cos_ool(x)
+
+def use_func_pointer(fa, fb, x):
+    if x > 0:
+        return fa(x)
+    else:
+        return fb(x)
+
+def use_user_defined_symbols():
+    return cffi_foo(1, 2, 3)
+
+# The from_buffer method is member of cffi.FFI, and also of CompiledFFI objects
+# (cffi_usecases_ool.ffi is a CompiledFFI object) so we use both in these
+# functions.
+
+def vector_sin_float32(x, y):
+    vsSin(len(x), ffi.from_buffer(x), ffi_ool.from_buffer(y))
+
+def vector_sin_float64(x, y):
+    vdSin(len(x), ffi.from_buffer(x), ffi_ool.from_buffer(y))
+
+
+# For testing pointer to structs from buffers
+
+def vector_extract_real(x, y):
+    vector_real(ffi.from_buffer(x), ffi.from_buffer(y), len(x))
+
+def vector_extract_imag(x, y):
+    vector_imag(ffi.from_buffer(x), ffi.from_buffer(y), len(x))

.venv/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)

.venv/lib/python3.11/site-packages/numba/tests/chained_assign_usecases.py

@@ -0,0 +1,69 @@
+from numba import jit
+import numpy as np
+
+
+@jit
+def inc(a):
+    for i in range(len(a)):
+        a[i] += 1
+    return a
+
+
+@jit
+def inc1(a):
+    a[0] += 1
+    return a[0]
+
+
+@jit
+def inc2(a):
+    a[0] += 1
+    return a[0], a[0] + 1
+
+
+def chain1(a):
+    x = y = z = inc(a)
+    return x + y + z
+
+
+def chain2(v):
+    a = np.zeros(2)
+    a[0] = x = a[1] = v
+    return a[0] + a[1] + (x / 2)
+
+
+def unpack1(x, y):
+    a, b = x, y
+    return a + b / 2
+
+
+def unpack2(x, y):
+    a, b = c, d = inc1(x), inc1(y)
+    return a + c / 2, b + d / 2
+
+
+def chain3(x, y):
+    a = (b, c) = (inc1(x), inc1(y))
+    (d, e) = f = (inc1(x), inc1(y))
+    return (a[0] + b / 2 + d + f[0]), (a[1] + c + e / 2 + f[1])
+
+
+def unpack3(x):
+    a, b = inc2(x)
+    return a + b / 2
+
+
+def unpack4(x):
+    a, b = c, d = inc2(x)
+    return a + c / 2, b + d / 2
+
+
+def unpack5(x):
+    a = b, c = inc2(x)
+    d, e = f = inc2(x)
+    return (a[0] + b / 2 + d + f[0]), (a[1] + c + e / 2 + f[1])
+
+
+def unpack6(x, y):
+    (a, b), (c, d) = (x, y), (y + 1, x + 1)
+    return a + c / 2, b / 2 + d

.venv/lib/python3.11/site-packages/numba/tests/cloudpickle_main_class.py

@@ -0,0 +1,6 @@
+# Expected to run this module as __main__
+
+
+# Cloudpickle will think this is a dynamic class when this module is __main__
+class Klass:
+    classvar = None

.venv/lib/python3.11/site-packages/numba/tests/compile_with_pycc.py

@@ -0,0 +1,147 @@
+import cmath
+
+import numpy as np
+
+from numba import float32
+from numba.types import unicode_type, i8
+from numba.pycc import CC, exportmany, export
+from numba.tests.support import has_blas
+from numba import typed
+
+
+#
+# New API
+#
+
+cc = CC('pycc_test_simple')
+cc.use_nrt = False
+
+# Note the first signature omits the return type
+@cc.export('multf', (float32, float32))
+@cc.export('multi', 'i4(i4, i4)')
+def mult(a, b):
+    return a * b
+
+# Test imported C globals such as Py_None, PyExc_ZeroDivisionError
+@cc.export('get_none', 'none()')
+def get_none():
+    return None
+
+@cc.export('div', 'f8(f8, f8)')
+def div(x, y):
+    return x / y
+
+_two = 2
+
+# This one can't be compiled by the legacy API as it doesn't execute
+# the script in a proper module.
+@cc.export('square', 'i8(i8)')
+def square(u):
+    return u ** _two
+
+# These ones need helperlib
+cc_helperlib = CC('pycc_test_helperlib')
+cc_helperlib.use_nrt = False
+
+@cc_helperlib.export('power', 'i8(i8, i8)')
+def power(u, v):
+    return u ** v
+
+@cc_helperlib.export('sqrt', 'c16(c16)')
+def sqrt(u):
+    return cmath.sqrt(u)
+
+@cc_helperlib.export('size', 'i8(f8[:])')
+def size(arr):
+    return arr.size
+
+# Exercise linking to Numpy math functions
+@cc_helperlib.export('np_sqrt', 'f8(f8)')
+def np_sqrt(u):
+    return np.sqrt(u)
+
+@cc_helperlib.export('spacing', 'f8(f8)')
+def np_spacing(u):
+    return np.spacing(u)
+
+
+# This one clashes with libc random() unless pycc is careful with naming.
+@cc_helperlib.export('random', 'f8(i4)')
+def random_impl(seed):
+    if seed != -1:
+        np.random.seed(seed)
+    return np.random.random()
+
+# These ones need NRT
+cc_nrt = CC('pycc_test_nrt')
+
+@cc_nrt.export('zero_scalar', 'f8(i4)')
+def zero_scalar(n):
+    arr = np.zeros(n)
+    return arr[-1]
+
+if has_blas:
+    # This one also needs BLAS
+    @cc_nrt.export('vector_dot', 'f8(i4)')
+    def vector_dot(n):
+        a = np.linspace(1, n, n)
+        return np.dot(a, a)
+
+# This one needs an environment
+@cc_nrt.export('zeros', 'f8[:](i4)')
+def zeros(n):
+    return np.zeros(n)
+
+# requires list dtor, #issue3535
+@cc_nrt.export('np_argsort', 'intp[:](float64[:])')
+def np_argsort(arr):
+    return np.argsort(arr)
+
+#
+# Legacy API
+#
+
+exportmany(['multf f4(f4,f4)', 'multi i4(i4,i4)'])(mult)
+# Needs to link to helperlib to due with complex arguments
+# export('multc c16(c16,c16)')(mult)
+export('mult f8(f8, f8)')(mult)
+
+
+@cc_nrt.export('dict_usecase', 'intp[:](intp[:])')
+def dict_usecase(arr):
+    d = typed.Dict()
+    for i in range(arr.size):
+        d[i] = arr[i]
+    out = np.zeros_like(arr)
+    for k, v in d.items():
+        out[k] = k * v
+    return out
+
+# checks for issue #6386
+@cc_nrt.export('internal_str_dict', i8(unicode_type))
+def internal_str_dict(x):
+    d = typed.Dict.empty(unicode_type,i8)
+    if(x not in d):
+        d[x] = len(d)
+    return len(d)
+
+@cc_nrt.export('hash_str', i8(unicode_type))
+def internal_str_dict(x):
+    return hash(x)
+
+@cc_nrt.export('hash_literal_str_A', i8())
+def internal_str_dict():
+    return hash("A")
+
+
+# For testing dynamic exception symbol collision/linkage
+
+cc_dynexc = CC('pycc_test_dynamic_exc')
+
+@cc_dynexc.export('do_setitem1', 'void(f8[:, :], f8[:, :])')
+def do_setitem1(a, b):
+    a[:, :] = b
+
+@cc_dynexc.export('do_setitem2', 'void(f8[:, :], f8[:, :])')
+def do_setitem2(a, b):
+    a[:, :] = b

.venv/lib/python3.11/site-packages/numba/tests/complex_usecases.py

@@ -0,0 +1,93 @@
+import cmath
+
+
+def div_usecase(x, y):
+    return x / y
+
+
+def real_usecase(x):
+    return x.real
+
+def imag_usecase(x):
+    return x.imag
+
+def conjugate_usecase(x):
+    return x.conjugate()
+
+
+def acos_usecase(x):
+    return cmath.acos(x)
+
+def cos_usecase(x):
+    return cmath.cos(x)
+
+def asin_usecase(x):
+    return cmath.asin(x)
+
+def sin_usecase(x):
+    return cmath.sin(x)
+
+def atan_usecase(x):
+    return cmath.atan(x)
+
+def tan_usecase(x):
+    return cmath.tan(x)
+
+def acosh_usecase(x):
+    return cmath.acosh(x)
+
+def cosh_usecase(x):
+    return cmath.cosh(x)
+
+def asinh_usecase(x):
+    return cmath.asinh(x)
+
+def sinh_usecase(x):
+    return cmath.sinh(x)
+
+def atanh_usecase(x):
+    return cmath.atanh(x)
+
+def tanh_usecase(x):
+    return cmath.tanh(x)
+
+def exp_usecase(x):
+    return cmath.exp(x)
+
+def isfinite_usecase(x):
+    return cmath.isfinite(x)
+
+def isinf_usecase(x):
+    return cmath.isinf(x)
+
+def isnan_usecase(x):
+    return cmath.isnan(x)
+
+def log_usecase(x):
+    return cmath.log(x)
+
+def log_base_usecase(x, base):
+    return cmath.log(x, base)
+
+def log10_usecase(x):
+    return cmath.log10(x)
+
+def phase_usecase(x):
+    return cmath.phase(x)
+
+def polar_usecase(x):
+    return cmath.polar(x)
+
+_two = 2.0
+
+def polar_as_complex_usecase(x):
+    # HACK: clear errno by invoking float.__pow__
+    # (workaround for http://bugs.python.org/issue24489)
+    _two ** _two
+    return complex(*cmath.polar(x))
+
+def rect_usecase(r, phi):
+    return cmath.rect(r, phi)
+
+def sqrt_usecase(x):
+    return cmath.sqrt(x)

.venv/lib/python3.11/site-packages/numba/tests/ctypes_usecases.py

@@ -0,0 +1,114 @@
+from ctypes import *
+import sys
+
+import numpy as np
+
+
+is_windows = sys.platform.startswith('win32')
+
+# We can't rely on libc availability on Windows anymore, so we use our
+# own compiled wrappers (see https://bugs.python.org/issue23606).
+
+from numba import _helperlib
+libnumba = CDLL(_helperlib.__file__)
+del _helperlib
+
+# A typed C function (cdecl under Windows)
+
+c_sin = libnumba._numba_test_sin
+c_sin.argtypes = [c_double]
+c_sin.restype = c_double
+
+def use_c_sin(x):
+    return c_sin(x)
+
+c_cos = libnumba._numba_test_cos
+c_cos.argtypes = [c_double]
+c_cos.restype = c_double
+
+def use_two_funcs(x):
+    return c_sin(x) - c_cos(x)
+
+# Typed C functions accepting an array pointer
+# (either as a "void *" or as a typed pointer)
+
+c_vsquare = libnumba._numba_test_vsquare
+c_vsquare.argtypes = [c_int, c_void_p, c_void_p]
+
+c_vcube = libnumba._numba_test_vsquare
+c_vcube.argtypes = [c_int, POINTER(c_double), POINTER(c_double)]
+
+def use_c_vsquare(x):
+    out = np.empty_like(x)
+    c_vsquare(x.size, x.ctypes, out.ctypes)
+    return out
+
+def use_c_vcube(x):
+    out = np.empty_like(x)
+    c_vcube(x.size, x.ctypes, out.ctypes)
+    return out
+
+# An untyped C function
+
+c_untyped = libnumba._numba_test_exp
+
+def use_c_untyped(x):
+    return c_untyped(x)
+
+# A C function wrapped in a CFUNCTYPE
+
+ctype_wrapping = CFUNCTYPE(c_double, c_double)(use_c_sin)
+
+def use_ctype_wrapping(x):
+    return ctype_wrapping(x)
+
+# A Python API function
+
+savethread = pythonapi.PyEval_SaveThread
+savethread.argtypes = []
+savethread.restype = c_void_p
+
+restorethread = pythonapi.PyEval_RestoreThread
+restorethread.argtypes = [c_void_p]
+restorethread.restype = None
+
+if is_windows:
+    # A function with the stdcall calling convention
+    c_sleep = windll.kernel32.Sleep
+    c_sleep.argtypes = [c_uint]
+    c_sleep.restype = None
+
+    def use_c_sleep(x):
+        c_sleep(x)
+
+
+def use_c_pointer(x):
+    """
+    Running in Python will cause a segfault.
+    """
+    threadstate = savethread()
+    x += 1
+    restorethread(threadstate)
+    return x
+
+
+def use_func_pointer(fa, fb, x):
+    if x > 0:
+        return fa(x)
+    else:
+        return fb(x)
+
+
+mydct = {'what': 1232121}
+
+def call_me_maybe(arr):
+    return mydct[arr[0].decode('ascii')]
+
+# Create a callback into the python interpreter
+py_call_back = CFUNCTYPE(c_int, py_object)(call_me_maybe)
+
+
+def take_array_ptr(ptr):
+    return ptr
+
+c_take_array_ptr = CFUNCTYPE(c_void_p, c_void_p)(take_array_ptr)

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/__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

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/test_examples.py

@@ -0,0 +1,660 @@
+# Contents in this file are referenced from the sphinx-generated docs.
+# "magictoken" is used for markers as beginning and ending of example text.
+
+import sys
+import unittest
+
+from numba.tests.support import TestCase, captured_stdout
+from numba.core.config import IS_WIN32
+from numba.np.numpy_support import numpy_version
+
+
+class MatplotlibBlocker:
+    '''Blocks the import of matplotlib, so that doc examples that attempt to
+    plot the output don't result in plots popping up and blocking testing.'''
+
+    def find_spec(self, fullname, path, target=None):
+        if fullname == 'matplotlib':
+            msg = 'Blocked import of matplotlib for test suite run'
+            raise ImportError(msg)
+
+
+class DocsExamplesTest(TestCase):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._mpl_blocker = MatplotlibBlocker()
+
+    def setUp(self):
+        sys.meta_path.insert(0, self._mpl_blocker)
+
+    def tearDown(self):
+        sys.meta_path.remove(self._mpl_blocker)
+
+    def test_mandelbrot(self):
+        with captured_stdout():
+            # magictoken.ex_mandelbrot.begin
+            from timeit import default_timer as timer
+            try:
+                from matplotlib.pylab import imshow, show
+                have_mpl = True
+            except ImportError:
+                have_mpl = False
+            import numpy as np
+            from numba import jit
+
+            @jit(nopython=True)
+            def mandel(x, y, max_iters):
+                """
+                Given the real and imaginary parts of a complex number,
+                determine if it is a candidate for membership in the Mandelbrot
+                set given a fixed number of iterations.
+                """
+                i = 0
+                c = complex(x,y)
+                z = 0.0j
+                for i in range(max_iters):
+                    z = z * z + c
+                    if (z.real * z.real + z.imag * z.imag) >= 4:
+                        return i
+
+                return 255
+
+            @jit(nopython=True)
+            def create_fractal(min_x, max_x, min_y, max_y, image, iters):
+                height = image.shape[0]
+                width = image.shape[1]
+
+                pixel_size_x = (max_x - min_x) / width
+                pixel_size_y = (max_y - min_y) / height
+                for x in range(width):
+                    real = min_x + x * pixel_size_x
+                    for y in range(height):
+                        imag = min_y + y * pixel_size_y
+                        color = mandel(real, imag, iters)
+                        image[y, x] = color
+
+                return image
+
+            image = np.zeros((500 * 2, 750 * 2), dtype=np.uint8)
+            s = timer()
+            create_fractal(-2.0, 1.0, -1.0, 1.0, image, 20)
+            e = timer()
+            print(e - s)
+            if have_mpl:
+                imshow(image)
+                show()
+            # magictoken.ex_mandelbrot.end
+
+    def test_moving_average(self):
+        with captured_stdout():
+            # magictoken.ex_moving_average.begin
+            import numpy as np
+
+            from numba import guvectorize
+
+            @guvectorize(['void(float64[:], intp[:], float64[:])'],
+                         '(n),()->(n)')
+            def move_mean(a, window_arr, out):
+                window_width = window_arr[0]
+                asum = 0.0
+                count = 0
+                for i in range(window_width):
+                    asum += a[i]
+                    count += 1
+                    out[i] = asum / count
+                for i in range(window_width, len(a)):
+                    asum += a[i] - a[i - window_width]
+                    out[i] = asum / count
+
+            arr = np.arange(20, dtype=np.float64).reshape(2, 10)
+            print(arr)
+            print(move_mean(arr, 3))
+            # magictoken.ex_moving_average.end
+
+    def test_nogil(self):
+        with captured_stdout():
+            # magictoken.ex_no_gil.begin
+            import math
+            import threading
+            from timeit import repeat
+
+            import numpy as np
+            from numba import jit
+
+            nthreads = 4
+            size = 10**6
+
+            def func_np(a, b):
+                """
+                Control function using Numpy.
+                """
+                return np.exp(2.1 * a + 3.2 * b)
+
+            @jit('void(double[:], double[:], double[:])', nopython=True,
+                 nogil=True)
+            def inner_func_nb(result, a, b):
+                """
+                Function under test.
+                """
+                for i in range(len(result)):
+                    result[i] = math.exp(2.1 * a[i] + 3.2 * b[i])
+
+            def timefunc(correct, s, func, *args, **kwargs):
+                """
+                Benchmark *func* and print out its runtime.
+                """
+                print(s.ljust(20), end=" ")
+                # Make sure the function is compiled before the benchmark is
+                # started
+                res = func(*args, **kwargs)
+                if correct is not None:
+                    assert np.allclose(res, correct), (res, correct)
+                # time it
+                print('{:>5.0f} ms'.format(min(repeat(
+                    lambda: func(*args, **kwargs), number=5, repeat=2)) * 1000))
+                return res
+
+            def make_singlethread(inner_func):
+                """
+                Run the given function inside a single thread.
+                """
+                def func(*args):
+                    length = len(args[0])
+                    result = np.empty(length, dtype=np.float64)
+                    inner_func(result, *args)
+                    return result
+                return func
+
+            def make_multithread(inner_func, numthreads):
+                """
+                Run the given function inside *numthreads* threads, splitting
+                its arguments into equal-sized chunks.
+                """
+                def func_mt(*args):
+                    length = len(args[0])
+                    result = np.empty(length, dtype=np.float64)
+                    args = (result,) + args
+                    chunklen = (length + numthreads - 1) // numthreads
+                    # Create argument tuples for each input chunk
+                    chunks = [[arg[i * chunklen:(i + 1) * chunklen] for arg in
+                               args] for i in range(numthreads)]
+                    # Spawn one thread per chunk
+                    threads = [threading.Thread(target=inner_func, args=chunk)
+                               for chunk in chunks]
+                    for thread in threads:
+                        thread.start()
+                    for thread in threads:
+                        thread.join()
+                    return result
+                return func_mt
+
+            func_nb = make_singlethread(inner_func_nb)
+            func_nb_mt = make_multithread(inner_func_nb, nthreads)
+
+            a = np.random.rand(size)
+            b = np.random.rand(size)
+
+            correct = timefunc(None, "numpy (1 thread)", func_np, a, b)
+            timefunc(correct, "numba (1 thread)", func_nb, a, b)
+            timefunc(correct, "numba (%d threads)" % nthreads, func_nb_mt, a, b)
+            # magictoken.ex_no_gil.end
+
+    def test_vectorize_one_signature(self):
+        with captured_stdout():
+            # magictoken.ex_vectorize_one_signature.begin
+            from numba import vectorize, float64
+
+            @vectorize([float64(float64, float64)])
+            def f(x, y):
+                return x + y
+            # magictoken.ex_vectorize_one_signature.end
+
+    def test_vectorize_multiple_signatures(self):
+        with captured_stdout():
+            # magictoken.ex_vectorize_multiple_signatures.begin
+            from numba import vectorize, int32, int64, float32, float64
+            import numpy as np
+
+            @vectorize([int32(int32, int32),
+                        int64(int64, int64),
+                        float32(float32, float32),
+                        float64(float64, float64)])
+            def f(x, y):
+                return x + y
+            # magictoken.ex_vectorize_multiple_signatures.end
+
+            # magictoken.ex_vectorize_return_call_one.begin
+            a = np.arange(6)
+            result = f(a, a)
+            # result == array([ 0,  2,  4,  6,  8, 10])
+            # magictoken.ex_vectorize_return_call_one.end
+
+            self.assertIsInstance(result, np.ndarray)
+            correct = np.array([0, 2, 4, 6, 8, 10])
+            np.testing.assert_array_equal(result, correct)
+
+            # magictoken.ex_vectorize_return_call_two.begin
+            a = np.linspace(0, 1, 6)
+            result = f(a, a)
+            # Now, result == array([0. , 0.4, 0.8, 1.2, 1.6, 2. ])
+            # magictoken.ex_vectorize_return_call_two.end
+
+            self.assertIsInstance(result, np.ndarray)
+            correct = np.array([0., 0.4, 0.8, 1.2, 1.6, 2. ])
+            np.testing.assert_allclose(result, correct)
+
+            # magictoken.ex_vectorize_return_call_three.begin
+            a = np.arange(12).reshape(3, 4)
+            # a == array([[ 0,  1,  2,  3],
+            #             [ 4,  5,  6,  7],
+            #             [ 8,  9, 10, 11]])
+
+            result1 = f.reduce(a, axis=0)
+            # result1 == array([12, 15, 18, 21])
+
+            result2 = f.reduce(a, axis=1)
+            # result2 == array([ 6, 22, 38])
+
+            result3 = f.accumulate(a)
+            # result3 == array([[ 0,  1,  2,  3],
+            #                   [ 4,  6,  8, 10],
+            #                   [12, 15, 18, 21]])
+
+            result4 = f.accumulate(a, axis=1)
+            # result3 == array([[ 0,  1,  3,  6],
+            #                   [ 4,  9, 15, 22],
+            #                   [ 8, 17, 27, 38]])
+            # magictoken.ex_vectorize_return_call_three.end
+
+            self.assertIsInstance(result1, np.ndarray)
+            correct = np.array([12, 15, 18, 21])
+            np.testing.assert_array_equal(result1, correct)
+
+            self.assertIsInstance(result2, np.ndarray)
+            correct = np.array([6, 22, 38])
+            np.testing.assert_array_equal(result2, correct)
+
+            self.assertIsInstance(result3, np.ndarray)
+            correct = np.array([
+                [0, 1, 2, 3],
+                [4, 6, 8, 10],
+                [12, 15, 18, 21]
+            ])
+            np.testing.assert_array_equal(result3, correct)
+
+            self.assertIsInstance(result4, np.ndarray)
+            correct = np.array([
+                [0, 1, 3, 6],
+                [4, 9, 15, 22],
+                [8, 17, 27, 38]
+            ])
+            np.testing.assert_array_equal(result4, correct)
+
+    def test_guvectorize(self):
+        with captured_stdout():
+            # magictoken.ex_guvectorize.begin
+            from numba import guvectorize, int64
+            import numpy as np
+
+            @guvectorize([(int64[:], int64, int64[:])], '(n),()->(n)')
+            def g(x, y, res):
+                for i in range(x.shape[0]):
+                    res[i] = x[i] + y
+            # magictoken.ex_guvectorize.end
+
+            # magictoken.ex_guvectorize_call_one.begin
+            a = np.arange(5)
+            result = g(a, 2)
+            # result == array([2, 3, 4, 5, 6])
+            # magictoken.ex_guvectorize_call_one.end
+
+            self.assertIsInstance(result, np.ndarray)
+            correct = np.array([2, 3, 4, 5, 6])
+            np.testing.assert_array_equal(result, correct)
+
+            # magictoken.ex_guvectorize_call_two.begin
+            a = np.arange(6).reshape(2, 3)
+            # a == array([[0, 1, 2],
+            #             [3, 4, 5]])
+
+            result1 = g(a, 10)
+            # result1 == array([[10, 11, 12],
+            #                   [13, 14, 15]])
+
+            result2 = g(a, np.array([10, 20]))
+            g(a, np.array([10, 20]))
+            # result2 == array([[10, 11, 12],
+            #                   [23, 24, 25]])
+            # magictoken.ex_guvectorize_call_two.end
+
+            self.assertIsInstance(result1, np.ndarray)
+            correct = np.array([[10, 11, 12], [13, 14, 15]])
+            np.testing.assert_array_equal(result1, correct)
+
+            self.assertIsInstance(result2, np.ndarray)
+            correct = np.array([[10, 11, 12], [23, 24, 25]])
+            np.testing.assert_array_equal(result2, correct)
+
+    def test_guvectorize_scalar_return(self):
+        with captured_stdout():
+            # magictoken.ex_guvectorize_scalar_return.begin
+            from numba import guvectorize, int64
+            import numpy as np
+
+            @guvectorize([(int64[:], int64, int64[:])], '(n),()->()')
+            def g(x, y, res):
+                acc = 0
+                for i in range(x.shape[0]):
+                    acc += x[i] + y
+                res[0] = acc
+            # magictoken.ex_guvectorize_scalar_return.end
+
+            # magictoken.ex_guvectorize_scalar_return_call.begin
+            a = np.arange(5)
+            result = g(a, 2)
+            # At this point, result == 20.
+            # magictoken.ex_guvectorize_scalar_return_call.end
+
+            self.assertIsInstance(result, np.integer)
+            self.assertEqual(result, 20)
+
+    def test_guvectorize_jit(self):
+        with captured_stdout():
+            # magictoken.gufunc_jit.begin
+            import numpy as np
+
+            from numba import jit, guvectorize
+
+            @guvectorize('(n)->(n)')
+            def copy(x, res):
+                for i in range(x.shape[0]):
+                    res[i] = x[i]
+
+            @jit(nopython=True)
+            def jit_fn(x, res):
+                copy(x, res)
+            # magictoken.gufunc_jit.end
+
+            # magictoken.gufunc_jit_call.begin
+            x = np.arange(5, dtype='i4')
+            res = np.zeros_like(x)
+            jit_fn(x, res)
+            # At this point, res == np.array([0, 1, 2, 3, 4], 'i4').
+            # magictoken.gufunc_jit_call.end
+            self.assertPreciseEqual(x, res)
+
+    def test_guvectorize_jit_fail(self):
+        with captured_stdout():
+            # magictoken.gufunc_jit_fail.begin
+            import numpy as np
+            from numba import jit, guvectorize
+
+            @guvectorize('(n)->(n)')
+            def copy(x, res):
+                for i in range(x.shape[0]):
+                    res[i] = x[i]
+
+            @jit(nopython=True)
+            def jit_fn(x, res):
+                copy(x, res)
+
+            x = np.ones((1, 5))
+            res = np.empty((5,))
+            with self.assertRaises(ValueError) as raises:
+                jit_fn(x, res)
+            # magictoken.gufunc_jit_fail.end
+            self.assertIn('Loop and array shapes are incompatible',
+                          str(raises.exception))
+
+    def test_guvectorize_overwrite(self):
+        with captured_stdout():
+            # magictoken.ex_guvectorize_overwrite.begin
+            from numba import guvectorize, float64
+            import numpy as np
+
+            @guvectorize([(float64[:], float64[:])], '()->()')
+            def init_values(invals, outvals):
+                invals[0] = 6.5
+                outvals[0] = 4.2
+            # magictoken.ex_guvectorize_overwrite.end
+
+            # magictoken.ex_guvectorize_overwrite_call_one.begin
+            invals = np.zeros(shape=(3, 3), dtype=np.float64)
+            # invals == array([[6.5, 6.5, 6.5],
+            #                  [6.5, 6.5, 6.5],
+            #                  [6.5, 6.5, 6.5]])
+
+            outvals = init_values(invals)
+            # outvals == array([[4.2, 4.2, 4.2],
+            #                   [4.2, 4.2, 4.2],
+            #                   [4.2, 4.2, 4.2]])
+            # magictoken.ex_guvectorize_overwrite_call_one.end
+
+            self.assertIsInstance(invals, np.ndarray)
+            correct = np.array([
+                [6.5, 6.5, 6.5],
+                [6.5, 6.5, 6.5],
+                [6.5, 6.5, 6.5]])
+            np.testing.assert_array_equal(invals, correct)
+
+            self.assertIsInstance(outvals, np.ndarray)
+            correct = np.array([
+                [4.2, 4.2, 4.2],
+                [4.2, 4.2, 4.2],
+                [4.2, 4.2, 4.2]])
+            np.testing.assert_array_equal(outvals, correct)
+
+            # magictoken.ex_guvectorize_overwrite_call_two.begin
+            invals = np.zeros(shape=(3, 3), dtype=np.float32)
+            # invals == array([[0., 0., 0.],
+            #                  [0., 0., 0.],
+            #                  [0., 0., 0.]], dtype=float32)
+            outvals = init_values(invals)
+            # outvals == array([[4.2, 4.2, 4.2],
+            #                   [4.2, 4.2, 4.2],
+            #                   [4.2, 4.2, 4.2]])
+            print(invals)
+            # invals == array([[0., 0., 0.],
+            #                  [0., 0., 0.],
+            #                  [0., 0., 0.]], dtype=float32)
+            # magictoken.ex_guvectorize_overwrite_call_two.end
+
+            self.assertIsInstance(invals, np.ndarray)
+            correct = np.array([
+                [0., 0., 0.],
+                [0., 0., 0.],
+                [0., 0., 0.]], dtype=np.float32)
+            np.testing.assert_array_equal(invals, correct)
+
+            self.assertIsInstance(outvals, np.ndarray)
+            correct = np.array([
+                [4.2, 4.2, 4.2],
+                [4.2, 4.2, 4.2],
+                [4.2, 4.2, 4.2]])
+            np.testing.assert_array_equal(outvals, correct)
+
+            # magictoken.ex_guvectorize_overwrite_call_three.begin
+            @guvectorize(
+                [(float64[:], float64[:])],
+                '()->()',
+                writable_args=('invals',)
+            )
+            def init_values(invals, outvals):
+                invals[0] = 6.5
+                outvals[0] = 4.2
+
+            invals = np.zeros(shape=(3, 3), dtype=np.float32)
+            # invals == array([[0., 0., 0.],
+            #                  [0., 0., 0.],
+            #                  [0., 0., 0.]], dtype=float32)
+            outvals = init_values(invals)
+            # outvals == array([[4.2, 4.2, 4.2],
+            #                   [4.2, 4.2, 4.2],
+            #                   [4.2, 4.2, 4.2]])
+            print(invals)
+            # invals == array([[6.5, 6.5, 6.5],
+            #                  [6.5, 6.5, 6.5],
+            #                  [6.5, 6.5, 6.5]], dtype=float32)
+            # magictoken.ex_guvectorize_overwrite_call_three.end
+
+            self.assertIsInstance(invals, np.ndarray)
+            correct = np.array([
+                [6.5, 6.5, 6.5],
+                [6.5, 6.5, 6.5],
+                [6.5, 6.5, 6.5]])
+            np.testing.assert_array_equal(invals, correct)
+
+            self.assertIsInstance(outvals, np.ndarray)
+            correct = np.array([
+                [4.2, 4.2, 4.2],
+                [4.2, 4.2, 4.2],
+                [4.2, 4.2, 4.2]])
+            np.testing.assert_array_equal(outvals, correct)
+
+    def test_vectorize_dynamic(self):
+        with captured_stdout():
+            # magictoken.ex_vectorize_dynamic.begin
+            from numba import vectorize
+
+            @vectorize
+            def f(x, y):
+                return x * y
+            # magictoken.ex_vectorize_dynamic.end
+
+            # magictoken.ex_vectorize_dynamic_call_one.begin
+            result = f(3,4)
+            # result == 12
+
+            print(f.types)
+            # ['ll->l']
+            # magictoken.ex_vectorize_dynamic_call_one.end
+
+            self.assertEqual(result, 12)
+            if IS_WIN32:
+                if numpy_version < (2, 0):
+                    correct = ['ll->q']
+                else:
+                    correct = ['qq->q']
+            else:
+                correct = ['ll->l']
+            self.assertEqual(f.types, correct)
+
+            # magictoken.ex_vectorize_dynamic_call_two.begin
+            result = f(1.,2.)
+            # result == 2.0
+
+            print(f.types)
+            # ['ll->l', 'dd->d']
+            # magictoken.ex_vectorize_dynamic_call_two.end
+
+            self.assertEqual(result, 2.0)
+            if IS_WIN32:
+                if numpy_version < (2, 0):
+                    correct = ['ll->q', 'dd->d']
+                else:
+                    correct = ['qq->q', 'dd->d']
+            else:
+                correct = ['ll->l', 'dd->d']
+            self.assertEqual(f.types, correct)
+
+            # magictoken.ex_vectorize_dynamic_call_three.begin
+            result = f(1,2.)
+            # result == 2.0
+
+            print(f.types)
+            # ['ll->l', 'dd->d']
+            # magictoken.ex_vectorize_dynamic_call_three.end
+
+            self.assertEqual(result, 2.0)
+            if IS_WIN32:
+                if numpy_version < (2, 0):
+                    correct = ['ll->q', 'dd->d']
+                else:
+                    correct = ['qq->q', 'dd->d']
+            else:
+                correct = ['ll->l', 'dd->d']
+            self.assertEqual(f.types, correct)
+
+            # magictoken.ex_vectorize_dynamic_call_four.begin
+            @vectorize
+            def g(a, b):
+                return a / b
+
+            print(g(2.,3.))
+            # 0.66666666666666663
+
+            print(g(2,3))
+            # 0.66666666666666663
+
+            print(g.types)
+            # ['dd->d']
+            # magictoken.ex_vectorize_dynamic_call_four.end
+
+            correct = ['dd->d']
+            self.assertEqual(g.types, correct)
+
+    def test_guvectorize_dynamic(self):
+        with captured_stdout():
+            # magictoken.ex_guvectorize_dynamic.begin
+            from numba import guvectorize
+            import numpy as np
+
+            @guvectorize('(n),()->(n)')
+            def g(x, y, res):
+                for i in range(x.shape[0]):
+                    res[i] = x[i] + y
+            # magictoken.ex_guvectorize_dynamic.end
+
+            # magictoken.ex_guvectorize_dynamic_call_one.begin
+            x = np.arange(5, dtype=np.int64)
+            y = 10
+            res = np.zeros_like(x)
+            g(x, y, res)
+            # res == array([10, 11, 12, 13, 14])
+            print(g.types)
+            # ['ll->l']
+            # magictoken.ex_guvectorize_dynamic_call_one.end
+
+            correct = np.array([10, 11, 12, 13, 14])
+            np.testing.assert_array_equal(res, correct)
+            if IS_WIN32:
+                correct = ['qq->q']
+            else:
+                correct = ['ll->l']
+            self.assertEqual(g.types, correct)
+
+            # magictoken.ex_guvectorize_dynamic_call_two.begin
+            x = np.arange(5, dtype=np.double)
+            y = 2.2
+            res = np.zeros_like(x)
+            g(x, y, res)
+            # res == array([2.2, 3.2, 4.2, 5.2, 6.2])
+            # magictoken.ex_guvectorize_dynamic_call_two.end
+
+            # magictoken.ex_guvectorize_dynamic_call_three.begin
+            print(g.types) # shorthand for g.ufunc.types
+            # ['ll->l', 'dd->d']
+            # magictoken.ex_guvectorize_dynamic_call_three.end
+
+            if IS_WIN32:
+                correct = ['qq->q', 'dd->d']
+            else:
+                correct = ['ll->l', 'dd->d']
+            self.assertEqual(g.types, correct)
+
+            # magictoken.ex_guvectorize_dynamic_call_four.begin
+            x = np.arange(5, dtype=np.int64)
+            y = 2
+            res = np.zeros_like(x)
+            g(x, y, res)
+            print(res)
+            # res == array([2, 3, 4, 5, 6])
+            # magictoken.ex_guvectorize_dynamic_call_four.end
+
+            correct = np.array([2, 3, 4, 5, 6])
+            np.testing.assert_array_equal(res, correct)
+
+
+if __name__ == '__main__':
+    unittest.main()

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/test_interval_example.py

@@ -0,0 +1,242 @@
+"""
+This test is used by `docs/source/extending/interval-example.rst`.
+
+The "magictoken" comments are used as markers for the beginning and ending of
+example code.
+"""
+import unittest
+
+
+class IntervalExampleTest(unittest.TestCase):
+
+    def test_interval_class_usage(self):
+        # magictoken.interval_py_class.begin
+        class Interval(object):
+            """
+            A half-open interval on the real number line.
+            """
+            def __init__(self, lo, hi):
+                self.lo = lo
+                self.hi = hi
+
+            def __repr__(self):
+                return 'Interval(%f, %f)' % (self.lo, self.hi)
+
+            @property
+            def width(self):
+                return self.hi - self.lo
+        # magictoken.interval_py_class.end
+
+        # magictoken.interval_type_class.begin
+        from numba import types
+
+        class IntervalType(types.Type):
+            def __init__(self):
+                super(IntervalType, self).__init__(name='Interval')
+
+        interval_type = IntervalType()
+        # magictoken.interval_type_class.end
+
+        # magictoken.interval_typeof_register.begin
+        from numba.extending import typeof_impl
+
+        @typeof_impl.register(Interval)
+        def typeof_index(val, c):
+            return interval_type
+        # magictoken.interval_typeof_register.end
+
+        # magictoken.numba_type_register.begin
+        from numba.extending import as_numba_type
+
+        as_numba_type.register(Interval, interval_type)
+        # magictoken.numba_type_register.end
+
+        # magictoken.numba_type_callable.begin
+        from numba.extending import type_callable
+
+        @type_callable(Interval)
+        def type_interval(context):
+            def typer(lo, hi):
+                if isinstance(lo, types.Float) and isinstance(hi, types.Float):
+                    return interval_type
+            return typer
+        # magictoken.numba_type_callable.end
+
+        # magictoken.interval_model.begin
+        from numba.extending import models, register_model
+
+        @register_model(IntervalType)
+        class IntervalModel(models.StructModel):
+            def __init__(self, dmm, fe_type):
+                members = [('lo', types.float64),
+                           ('hi', types.float64),]
+                models.StructModel.__init__(self, dmm, fe_type, members)
+        # magictoken.interval_model.end
+
+        # magictoken.interval_attribute_wrapper.begin
+        from numba.extending import make_attribute_wrapper
+
+        make_attribute_wrapper(IntervalType, 'lo', 'lo')
+        make_attribute_wrapper(IntervalType, 'hi', 'hi')
+        # magictoken.interval_attribute_wrapper.end
+
+        # magictoken.interval_overload_attribute.begin
+        from numba.extending import overload_attribute
+
+        @overload_attribute(IntervalType, "width")
+        def get_width(interval):
+            def getter(interval):
+                return interval.hi - interval.lo
+            return getter
+        # magictoken.interval_overload_attribute.end
+
+        # magictoken.interval_lower_builtin.begin
+        from numba.extending import lower_builtin
+        from numba.core import cgutils
+
+        @lower_builtin(Interval, types.Float, types.Float)
+        def impl_interval(context, builder, sig, args):
+            typ = sig.return_type
+            lo, hi = args
+            interval = cgutils.create_struct_proxy(typ)(context, builder)
+            interval.lo = lo
+            interval.hi = hi
+            return interval._getvalue()
+        # magictoken.interval_lower_builtin.end
+
+        # magictoken.interval_unbox.begin
+        from numba.extending import unbox, NativeValue
+        from contextlib import ExitStack
+
+        @unbox(IntervalType)
+        def unbox_interval(typ, obj, c):
+            """
+            Convert a Interval object to a native interval structure.
+            """
+            is_error_ptr = cgutils.alloca_once_value(c.builder, cgutils.false_bit)
+            interval = cgutils.create_struct_proxy(typ)(c.context, c.builder)
+
+            with ExitStack() as stack:
+                lo_obj = c.pyapi.object_getattr_string(obj, "lo")
+                with cgutils.early_exit_if_null(c.builder, stack, lo_obj):
+                    c.builder.store(cgutils.true_bit, is_error_ptr)
+                lo_native = c.unbox(types.float64, lo_obj)
+                c.pyapi.decref(lo_obj)
+                with cgutils.early_exit_if(c.builder, stack, lo_native.is_error):
+                    c.builder.store(cgutils.true_bit, is_error_ptr)
+
+                hi_obj = c.pyapi.object_getattr_string(obj, "hi")
+                with cgutils.early_exit_if_null(c.builder, stack, hi_obj):
+                    c.builder.store(cgutils.true_bit, is_error_ptr)
+                hi_native = c.unbox(types.float64, hi_obj)
+                c.pyapi.decref(hi_obj)
+                with cgutils.early_exit_if(c.builder, stack, hi_native.is_error):
+                    c.builder.store(cgutils.true_bit, is_error_ptr)
+
+                interval.lo = lo_native.value
+                interval.hi = hi_native.value
+
+            return NativeValue(interval._getvalue(), is_error=c.builder.load(is_error_ptr))
+        # magictoken.interval_unbox.end
+
+        # magictoken.interval_box.begin
+        from numba.extending import box
+
+        @box(IntervalType)
+        def box_interval(typ, val, c):
+            """
+            Convert a native interval structure to an Interval object.
+            """
+            ret_ptr = cgutils.alloca_once(c.builder, c.pyapi.pyobj)
+            fail_obj = c.pyapi.get_null_object()
+
+            with ExitStack() as stack:
+                interval = cgutils.create_struct_proxy(typ)(c.context, c.builder, value=val)
+                lo_obj = c.box(types.float64, interval.lo)
+                with cgutils.early_exit_if_null(c.builder, stack, lo_obj):
+                    c.builder.store(fail_obj, ret_ptr)
+
+                hi_obj = c.box(types.float64, interval.hi)
+                with cgutils.early_exit_if_null(c.builder, stack, hi_obj):
+                    c.pyapi.decref(lo_obj)
+                    c.builder.store(fail_obj, ret_ptr)
+
+                class_obj = c.pyapi.unserialize(c.pyapi.serialize_object(Interval))
+                with cgutils.early_exit_if_null(c.builder, stack, class_obj):
+                    c.pyapi.decref(lo_obj)
+                    c.pyapi.decref(hi_obj)
+                    c.builder.store(fail_obj, ret_ptr)
+
+                # NOTE: The result of this call is not checked as the clean up
+                # has to occur regardless of whether it is successful. If it
+                # fails `res` is set to NULL and a Python exception is set.
+                res = c.pyapi.call_function_objargs(class_obj, (lo_obj, hi_obj))
+                c.pyapi.decref(lo_obj)
+                c.pyapi.decref(hi_obj)
+                c.pyapi.decref(class_obj)
+                c.builder.store(res, ret_ptr)
+
+            return c.builder.load(ret_ptr)
+        # magictoken.interval_box.end
+
+        # magictoken.interval_usage.begin
+        from numba import njit
+
+        @njit
+        def inside_interval(interval, x):
+            return interval.lo <= x < interval.hi
+
+        @njit
+        def interval_width(interval):
+            return interval.width
+
+        @njit
+        def sum_intervals(i, j):
+            return Interval(i.lo + j.lo, i.hi + j.hi)
+        # magictoken.interval_usage.end
+
+        def check_equal_intervals(x, y):
+            self.assertIsInstance(x, Interval)
+            self.assertIsInstance(y, Interval)
+            self.assertEqual(x.lo, y.lo)
+            self.assertEqual(x.hi, y.hi)
+
+        a = Interval(2, 3)
+        b = Interval(4, 5)
+        c = Interval(6, 8)
+
+        # Test box-unbox
+        return_func = njit(lambda x: x)
+        check_equal_intervals(a, return_func(a))
+
+        # Test .width attribute
+        self.assertEqual(a.width, interval_width(a))
+
+        # Test exceptions
+        class NotAFloat:
+            def __float__(self):
+                raise RuntimeError("I am not a float")
+
+        # TODO: This should produce a `RuntimeError`, but the `unbox` handler for `float` ignores
+        # the error raised by `__float__`, leading to a subsequent `TypeError` cause by passing
+        # `NULL` to `PyFloat_AsDouble`.
+        # This isn't the fault of the `Interval` extension that is being testing
+        # in this file.
+        with self.assertRaises(TypeError):
+            interval_width(Interval(2, NotAFloat()))
+
+        bad_interval = Interval(1, 2)
+        del bad_interval.hi
+
+        with self.assertRaises(AttributeError):
+            interval_width(bad_interval)
+
+        # Test .lo and .hi usage
+        self.assertFalse(inside_interval(a, 5))
+
+        # Test native Interval constructor
+        check_equal_intervals(c, sum_intervals(a, b))
+
+
+if __name__ == '__main__':
+    unittest.main()

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/test_jitclass.py

@@ -0,0 +1,97 @@
+# Contents in this file are referenced from the sphinx-generated docs.
+# "magictoken" is used for markers as beginning and ending of example text.
+
+import unittest
+from numba.tests.support import TestCase
+
+
+class DocsJitclassUsageTest(TestCase):
+
+    def test_ex_jitclass(self):
+        # magictoken.ex_jitclass.begin
+        import numpy as np
+        from numba import int32, float32    # import the types
+        from numba.experimental import jitclass
+
+        spec = [
+            ('value', int32),               # a simple scalar field
+            ('array', float32[:]),          # an array field
+        ]
+
+        @jitclass(spec)
+        class Bag(object):
+            def __init__(self, value):
+                self.value = value
+                self.array = np.zeros(value, dtype=np.float32)
+
+            @property
+            def size(self):
+                return self.array.size
+
+            def increment(self, val):
+                for i in range(self.size):
+                    self.array[i] += val
+                return self.array
+
+            @staticmethod
+            def add(x, y):
+                return x + y
+
+        n = 21
+        mybag = Bag(n)
+        # magictoken.ex_jitclass.end
+
+        self.assertTrue(isinstance(mybag, Bag))
+        self.assertPreciseEqual(mybag.value, n)
+        np.testing.assert_allclose(mybag.array, np.zeros(n, dtype=np.float32))
+        self.assertPreciseEqual(mybag.size, n)
+        np.testing.assert_allclose(mybag.increment(3),
+                                   3 * np.ones(n, dtype=np.float32))
+        np.testing.assert_allclose(mybag.increment(6),
+                                   9 * np.ones(n, dtype=np.float32))
+        self.assertPreciseEqual(mybag.add(1, 1), 2)
+        self.assertPreciseEqual(Bag.add(1, 2), 3)
+
+    def test_ex_jitclass_type_hints(self):
+        # magictoken.ex_jitclass_type_hints.begin
+        from typing import List
+        from numba.experimental import jitclass
+        from numba.typed import List as NumbaList
+
+        @jitclass
+        class Counter:
+            value: int
+
+            def __init__(self):
+                self.value = 0
+
+            def get(self) -> int:
+                ret = self.value
+                self.value += 1
+                return ret
+
+        @jitclass
+        class ListLoopIterator:
+            counter: Counter
+            items: List[float]
+
+            def __init__(self, items: List[float]):
+                self.items = items
+                self.counter = Counter()
+
+            def get(self) -> float:
+                idx = self.counter.get() % len(self.items)
+                return self.items[idx]
+
+        items = NumbaList([3.14, 2.718, 0.123, -4.])
+        loop_itr = ListLoopIterator(items)
+        # magictoken.ex_jitclass_type_hints.end
+
+        for idx in range(10):
+            self.assertEqual(loop_itr.counter.value, idx)
+            self.assertAlmostEqual(loop_itr.get(), items[idx % len(items)])
+            self.assertEqual(loop_itr.counter.value, idx + 1)
+
+
+if __name__ == '__main__':
+    unittest.main()

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/test_literal_container_usage.py

@@ -0,0 +1,161 @@
+# Contents in this file are referenced from the sphinx-generated docs.
+# "magictoken" is used for markers as beginning and ending of example text.
+
+import unittest
+from numba.tests.support import captured_stdout
+from numba import typed
+
+
+class DocsLiteralContainerUsageTest(unittest.TestCase):
+
+    def test_ex_literal_dict_compile_time_consts(self):
+        with captured_stdout():
+            # magictoken.test_ex_literal_dict_compile_time_consts.begin
+            import numpy as np
+            from numba import njit, types
+            from numba.extending import overload
+
+            # overload this function
+            def specialize(x):
+                pass
+
+            @overload(specialize)
+            def ol_specialize(x):
+                ld = x.literal_value
+                const_expr = []
+                for k, v in ld.items():
+                    if isinstance(v, types.Literal):
+                        lv = v.literal_value
+                        if lv == 'cat':
+                            const_expr.append("Meow!")
+                        elif lv == 'dog':
+                            const_expr.append("Woof!")
+                        elif isinstance(lv, int):
+                            const_expr.append(k.literal_value * lv)
+                    else: # it's an array
+                        const_expr.append("Array(dim={dim}".format(dim=v.ndim))
+                const_strings = tuple(const_expr)
+
+                def impl(x):
+                    return const_strings
+                return impl
+
+            @njit
+            def foo():
+                pets_ints_and_array = {'a': 1,
+                                       'b': 2,
+                                       'c': 'cat',
+                                       'd': 'dog',
+                                       'e': np.ones(5,)}
+                return specialize(pets_ints_and_array)
+
+            result = foo()
+            print(result) # ('a', 'bb', 'Meow!', 'Woof!', 'Array(dim=1')
+            # magictoken.test_ex_literal_dict_compile_time_consts.end
+
+        self.assertEqual(result, ('a', 'bb', 'Meow!', 'Woof!', 'Array(dim=1'))
+
+    def test_ex_initial_value_dict_compile_time_consts(self):
+        with captured_stdout():
+            # magictoken.test_ex_initial_value_dict_compile_time_consts.begin
+            from numba import njit, literally
+            from numba.extending import overload
+
+            # overload this function
+            def specialize(x):
+                pass
+
+            @overload(specialize)
+            def ol_specialize(x):
+                iv = x.initial_value
+                if iv is None:
+                    return lambda x: literally(x) # Force literal dispatch
+                assert iv == {'a': 1, 'b': 2, 'c': 3} # INITIAL VALUE
+                return lambda x: literally(x)
+
+            @njit
+            def foo():
+                d = {'a': 1, 'b': 2, 'c': 3}
+                d['c'] = 20 # no impact on .initial_value
+                d['d'] = 30 # no impact on .initial_value
+                return specialize(d)
+
+            result = foo()
+            print(result) # {a: 1, b: 2, c: 20, d: 30} # NOT INITIAL VALUE!
+            # magictoken.test_ex_initial_value_dict_compile_time_consts.end
+
+        expected = typed.Dict()
+        for k, v in {'a': 1, 'b': 2, 'c': 20, 'd': 30}.items():
+            expected[k] = v
+        self.assertEqual(result, expected)
+
+    def test_ex_literal_list(self):
+        with captured_stdout():
+            # magictoken.test_ex_literal_list.begin
+            from numba import njit
+            from numba.extending import overload
+
+            # overload this function
+            def specialize(x):
+                pass
+
+            @overload(specialize)
+            def ol_specialize(x):
+                l = x.literal_value
+                const_expr = []
+                for v in l:
+                    const_expr.append(str(v))
+                const_strings = tuple(const_expr)
+
+                def impl(x):
+                    return const_strings
+                return impl
+
+            @njit
+            def foo():
+                const_list = ['a', 10, 1j, ['another', 'list']]
+                return specialize(const_list)
+
+            result = foo()
+            print(result) # ('Literal[str](a)', 'Literal[int](10)', 'complex128', 'list(unicode_type)') # noqa E501
+            # magictoken.test_ex_literal_list.end
+
+        expected = ('Literal[str](a)', 'Literal[int](10)', 'complex128',
+                    "list(unicode_type)<iv=['another', 'list']>")
+        self.assertEqual(result, expected)
+
+    def test_ex_initial_value_list_compile_time_consts(self):
+        with captured_stdout():
+            # magictoken.test_ex_initial_value_list_compile_time_consts.begin
+            from numba import njit, literally
+            from numba.extending import overload
+
+            # overload this function
+            def specialize(x):
+                pass
+
+            @overload(specialize)
+            def ol_specialize(x):
+                iv = x.initial_value
+                if iv is None:
+                    return lambda x: literally(x) # Force literal dispatch
+                assert iv == [1, 2, 3] # INITIAL VALUE
+                return lambda x: x
+
+            @njit
+            def foo():
+                l = [1, 2, 3]
+                l[2] = 20 # no impact on .initial_value
+                l.append(30) # no impact on .initial_value
+                return specialize(l)
+
+            result = foo()
+            print(result) # [1, 2, 20, 30] # NOT INITIAL VALUE!
+            # magictoken.test_ex_initial_value_list_compile_time_consts.end
+
+        expected = [1, 2, 20, 30]
+        self.assertEqual(result, expected)
+
+
+if __name__ == '__main__':
+    unittest.main()

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/test_literally_usage.py

@@ -0,0 +1,59 @@
+# "magictoken" is used for markers as beginning and ending of example text.
+
+import unittest
+from numba.tests.support import captured_stdout
+
+
+class DocsLiterallyUsageTest(unittest.TestCase):
+
+    def test_literally_usage(self):
+        with captured_stdout() as stdout:
+            # magictoken.ex_literally_usage.begin
+            import numba
+
+            def power(x, n):
+                raise NotImplementedError
+
+            @numba.extending.overload(power)
+            def ov_power(x, n):
+                if isinstance(n, numba.types.Literal):
+                    # only if `n` is a literal
+                    if n.literal_value == 2:
+                        # special case: square
+                        print("square")
+                        return lambda x, n: x * x
+                    elif n.literal_value == 3:
+                        # special case: cubic
+                        print("cubic")
+                        return lambda x, n: x * x * x
+                else:
+                    # If `n` is not literal, request literal dispatch
+                    return lambda x, n: numba.literally(n)
+
+                print("generic")
+                return lambda x, n: x ** n
+
+            @numba.njit
+            def test_power(x, n):
+                return power(x, n)
+
+            # should print "square" and "9"
+            print(test_power(3, 2))
+
+            # should print "cubic" and "27"
+            print(test_power(3, 3))
+
+            # should print "generic" and "81"
+            print(test_power(3, 4))
+
+            # magictoken.ex_literally_usage.end
+            assert test_power(3, 2) == 3 ** 2
+            assert test_power(3, 3) == 3 ** 3
+            assert test_power(3, 4) == 3 ** 4
+
+        self.assertEqual('square\n9\ncubic\n27\ngeneric\n81\n',
+                         stdout.getvalue())
+
+
+if __name__ == '__main__':
+    unittest.main()

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/test_llvm_pass_timings.py

@@ -0,0 +1,31 @@
+# "magictoken" is used for markers as beginning and ending of example text.
+
+import unittest
+from numba.tests.support import captured_stdout, override_config
+
+
+class DocsLLVMPassTimings(unittest.TestCase):
+
+    def test_pass_timings(self):
+        with override_config('LLVM_PASS_TIMINGS', True):
+            with captured_stdout() as stdout:
+                # magictoken.ex_llvm_pass_timings.begin
+                import numba
+
+                @numba.njit
+                def foo(n):
+                    c = 0
+                    for i in range(n):
+                        for j in range(i):
+                            c += j
+                    return c
+
+                foo(10)
+                md = foo.get_metadata(foo.signatures[0])
+                print(md['llvm_pass_timings'])
+                # magictoken.ex_llvm_pass_timings.end
+            self.assertIn("Finalize object", stdout.getvalue())
+
+
+if __name__ == '__main__':
+    unittest.main()

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/test_numpy_generators.py

@@ -0,0 +1,38 @@
+# "magictoken" is used for markers as beginning and ending of example text.
+
+import unittest
+import numpy as np
+import numba
+
+
+class NumpyGeneratorUsageTest(unittest.TestCase):
+
+    def test_numpy_gen_usage(self):
+        # magictoken.npgen_usage.begin
+        x = np.random.default_rng(1)
+        y = np.random.default_rng(1)
+
+        size = 10
+
+        @numba.njit
+        def do_stuff(gen):
+            return gen.random(size=int(size / 2))
+
+        original = x.random(size=size)
+        # [0.51182162 0.9504637  0.14415961 0.94864945 0.31183145
+        #  0.42332645 0.82770259 0.40919914 0.54959369 0.02755911]
+
+        numba_func_res = do_stuff(y)
+        # [0.51182162 0.9504637  0.14415961 0.94864945 0.31183145]
+
+        after_numba = y.random(size=int(size / 2))
+        # [0.42332645 0.82770259 0.40919914 0.54959369 0.02755911]
+
+        # magictoken.npgen_usage.end
+        numba_res = np.concatenate((numba_func_res, after_numba))
+        for _np_res, _nb_res in zip(original, numba_res):
+            self.assertEqual(_np_res, _nb_res)
+
+
+if __name__ == '__main__':
+    unittest.main()

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/test_parallel_chunksize.py

@@ -0,0 +1,122 @@
+# Contents in this file are referenced from the sphinx-generated docs.
+# "magictoken" is used for markers as beginning and ending of example text.
+
+import unittest
+from numba.tests.support import captured_stdout, skip_parfors_unsupported
+from numba import set_parallel_chunksize
+from numba.tests.support import TestCase
+
+
+@skip_parfors_unsupported
+class ChunksizeExamplesTest(TestCase):
+
+    _numba_parallel_test_ = False
+
+    def setUp(self):
+        set_parallel_chunksize(0)
+
+    def tearDown(self):
+        set_parallel_chunksize(0)
+
+    def test_unbalanced_example(self):
+        with captured_stdout():
+            # magictoken.ex_unbalanced.begin
+            from numba import (njit,
+                               prange,
+                               )
+            import numpy as np
+
+            @njit(parallel=True)
+            def func1():
+                n = 100
+                vals = np.empty(n)
+                # The work in each iteration of the following prange
+                # loop is proportional to its index.
+                for i in prange(n):
+                    cur = i + 1
+                    for j in range(i):
+                        if cur % 2 == 0:
+                            cur //= 2
+                        else:
+                            cur = cur * 3 + 1
+                    vals[i] = cur
+                return vals
+
+            result = func1()
+            # magictoken.ex_unbalanced.end
+            self.assertPreciseEqual(result, func1.py_func())
+
+    def test_chunksize_manual(self):
+        with captured_stdout():
+            # magictoken.ex_chunksize_manual.begin
+            from numba import (njit,
+                               prange,
+                               set_parallel_chunksize,
+                               get_parallel_chunksize,
+                               )
+
+            @njit(parallel=True)
+            def func1(n):
+                acc = 0
+                print(get_parallel_chunksize()) # Will print 4.
+                for i in prange(n):
+                    print(get_parallel_chunksize()) # Will print 0.
+                    acc += i
+                print(get_parallel_chunksize()) # Will print 4.
+                return acc
+
+            @njit(parallel=True)
+            def func2(n):
+                acc = 0
+                # This version gets the previous chunksize explicitly.
+                old_chunksize = get_parallel_chunksize()
+                set_parallel_chunksize(8)
+                for i in prange(n):
+                    acc += i
+                set_parallel_chunksize(old_chunksize)
+                return acc
+
+            # This version saves the previous chunksize as returned
+            # by set_parallel_chunksize.
+            old_chunksize = set_parallel_chunksize(4)
+            result1 = func1(12)
+            result2 = func2(12)
+            result3 = func1(12)
+            set_parallel_chunksize(old_chunksize)
+            # magictoken.ex_chunksize_manual.end
+            self.assertPreciseEqual(result1, func1.py_func(12))
+            self.assertPreciseEqual(result2, func2.py_func(12))
+            self.assertPreciseEqual(result3, func1.py_func(12))
+
+    def test_chunksize_with(self):
+        with captured_stdout():
+            # magictoken.ex_chunksize_with.begin
+            from numba import njit, prange, parallel_chunksize
+
+            @njit(parallel=True)
+            def func1(n):
+                acc = 0
+                for i in prange(n):
+                    acc += i
+                return acc
+
+            @njit(parallel=True)
+            def func2(n):
+                acc = 0
+                with parallel_chunksize(8):
+                    for i in prange(n):
+                        acc += i
+                return acc
+
+            with parallel_chunksize(4):
+                result1 = func1(12)
+                result2 = func2(12)
+                result3 = func1(12)
+            # magictoken.ex_chunksize_with.end
+            self.assertPreciseEqual(result1, func1.py_func(12))
+            self.assertPreciseEqual(result2, func2.py_func(12))
+            self.assertPreciseEqual(result3, func1.py_func(12))
+
+
+if __name__ == '__main__':
+    unittest.main()

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/test_rec_array.py

@@ -0,0 +1,46 @@
+import unittest
+
+
+class TestExample(unittest.TestCase):
+
+    def test_documentation_example1(self):
+        # magictoken.ex_rec_arr_const_index.begin
+        import numpy as np
+        from numba import njit
+
+        arr = np.array([(1, 2)], dtype=[('a1', 'f8'), ('a2', 'f8')])
+        fields_gl = ('a1', 'a2')
+
+        @njit
+        def get_field_sum(rec):
+            fields_lc = ('a1', 'a2')
+            field_name1 = fields_lc[0]
+            field_name2 = fields_gl[1]
+            return rec[field_name1] + rec[field_name2]
+
+        get_field_sum(arr[0])  # returns 3
+        # magictoken.ex_rec_arr_const_index.end
+        self.assertEqual(get_field_sum(arr[0]), 3)
+
+    def test_documentation_example2(self):
+        # magictoken.ex_rec_arr_lit_unroll_index.begin
+        import numpy as np
+        from numba import njit, literal_unroll
+
+        arr = np.array([(1, 2)], dtype=[('a1', 'f8'), ('a2', 'f8')])
+        fields_gl = ('a1', 'a2')
+
+        @njit
+        def get_field_sum(rec):
+            out = 0
+            for f in literal_unroll(fields_gl):
+                out += rec[f]
+            return out
+
+        get_field_sum(arr[0])   # returns 3
+        # magictoken.ex_rec_arr_lit_unroll_index.end
+        self.assertEqual(get_field_sum(arr[0]), 3)
+
+
+if __name__ == '__main__':
+    unittest.main()

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/test_structref_usage.py

@@ -0,0 +1,149 @@
+# "magictoken" is used for markers as beginning and ending of example text.
+
+import unittest
+
+# magictoken.ex_structref_type_definition.begin
+import numpy as np
+
+from numba import njit
+from numba.core import types
+from numba.experimental import structref
+
+from numba.tests.support import skip_unless_scipy
+
+
+# Define a StructRef.
+# `structref.register` associates the type with the default data model.
+# This will also install getters and setters to the fields of
+# the StructRef.
+@structref.register
+class MyStructType(types.StructRef):
+    def preprocess_fields(self, fields):
+        # This method is called by the type constructor for additional
+        # preprocessing on the fields.
+        # Here, we don't want the struct to take Literal types.
+        return tuple((name, types.unliteral(typ)) for name, typ in fields)
+
+
+# Define a Python type that can be use as a proxy to the StructRef
+# allocated inside Numba. Users can construct the StructRef via
+# the constructor for this type in python code and jit-code.
+class MyStruct(structref.StructRefProxy):
+    def __new__(cls, name, vector):
+        # Overriding the __new__ method is optional, doing so
+        # allows Python code to use keyword arguments,
+        # or add other customized behavior.
+        # The default __new__ takes `*args`.
+        # IMPORTANT: Users should not override __init__.
+        return structref.StructRefProxy.__new__(cls, name, vector)
+
+    # By default, the proxy type does not reflect the attributes or
+    # methods to the Python side. It is up to users to define
+    # these. (This may be automated in the future.)
+
+    @property
+    def name(self):
+        # To access a field, we can define a function that simply
+        # return the field in jit-code.
+        # The definition of MyStruct_get_name is shown later.
+        return MyStruct_get_name(self)
+
+    @property
+    def vector(self):
+        # The definition of MyStruct_get_vector is shown later.
+        return MyStruct_get_vector(self)
+
+
+@njit
+def MyStruct_get_name(self):
+    # In jit-code, the StructRef's attribute is exposed via
+    # structref.register
+    return self.name
+
+
+@njit
+def MyStruct_get_vector(self):
+    return self.vector
+
+
+# This associates the proxy with MyStructType for the given set of
+# fields. Notice how we are not constraining the type of each field.
+# Field types remain generic.
+structref.define_proxy(MyStruct, MyStructType, ["name", "vector"])
+# magictoken.ex_structref_type_definition.end
+
+
+@skip_unless_scipy
+class TestStructRefUsage(unittest.TestCase):
+    def test_type_definition(self):
+        np.random.seed(0)
+        # Redirect print
+        buf = []
+
+        def print(*args):
+            buf.append(args)
+
+        # magictoken.ex_structref_type_definition_test.begin
+        # Let's test our new StructRef.
+
+        # Define one in Python
+        alice = MyStruct("Alice", vector=np.random.random(3))
+
+        # Define one in jit-code
+        @njit
+        def make_bob():
+            bob = MyStruct("unnamed", vector=np.zeros(3))
+            # Mutate the attributes
+            bob.name = "Bob"
+            bob.vector = np.random.random(3)
+            return bob
+
+        bob = make_bob()
+
+        # Out: Alice: [0.5488135  0.71518937 0.60276338]
+        print(f"{alice.name}: {alice.vector}")
+        # Out: Bob: [0.88325739 0.73527629 0.87746707]
+        print(f"{bob.name}: {bob.vector}")
+
+        # Define a jit function to operate on the structs.
+        @njit
+        def distance(a, b):
+            return np.linalg.norm(a.vector - b.vector)
+
+        # Out: 0.4332647200356598
+        print(distance(alice, bob))
+        # magictoken.ex_structref_type_definition_test.end
+
+        self.assertEqual(len(buf), 3)
+
+    def test_overload_method(self):
+        # magictoken.ex_structref_method.begin
+        from numba.core.extending import overload_method
+        from numba.core.errors import TypingError
+
+        # Use @overload_method to add a method for
+        # MyStructType.distance(other)
+        # where *other* is an instance of MyStructType.
+        @overload_method(MyStructType, "distance")
+        def ol_distance(self, other):
+            # Guard that *other* is an instance of MyStructType
+            if not isinstance(other, MyStructType):
+                raise TypingError(
+                    f"*other* must be a {MyStructType}; got {other}"
+                )
+
+            def impl(self, other):
+                return np.linalg.norm(self.vector - other.vector)
+
+            return impl
+
+        # Test
+        @njit
+        def test():
+            alice = MyStruct("Alice", vector=np.random.random(3))
+            bob = MyStruct("Bob", vector=np.random.random(3))
+            # Use the method
+            return alice.distance(bob)
+        # magictoken.ex_structref_method.end
+
+        self.assertIsInstance(test(), float)

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/test_typed_dict_usage.py

@@ -0,0 +1,111 @@
+# Contents in this file are referenced from the sphinx-generated docs.
+# "magictoken" is used for markers as beginning and ending of example text.
+
+import unittest
+from numba.tests.support import captured_stdout
+
+
+class DocsTypedDictUsageTest(unittest.TestCase):
+
+    def test_ex_typed_dict_from_cpython(self):
+        with captured_stdout():
+            # magictoken.ex_typed_dict_from_cpython.begin
+            import numpy as np
+            from numba import njit
+            from numba.core import types
+            from numba.typed import Dict
+
+            # The Dict.empty() constructs a typed dictionary.
+            # The key and value typed must be explicitly declared.
+            d = Dict.empty(
+                key_type=types.unicode_type,
+                value_type=types.float64[:],
+            )
+
+            # The typed-dict can be used from the interpreter.
+            d['posx'] = np.asarray([1, 0.5, 2], dtype='f8')
+            d['posy'] = np.asarray([1.5, 3.5, 2], dtype='f8')
+            d['velx'] = np.asarray([0.5, 0, 0.7], dtype='f8')
+            d['vely'] = np.asarray([0.2, -0.2, 0.1], dtype='f8')
+
+            # Here's a function that expects a typed-dict as the argument
+            @njit
+            def move(d):
+                # inplace operations on the arrays
+                d['posx'] += d['velx']
+                d['posy'] += d['vely']
+
+            print('posx: ', d['posx'])  # Out: posx:  [1.  0.5 2. ]
+            print('posy: ', d['posy'])  # Out: posy:  [1.5 3.5 2. ]
+
+            # Call move(d) to inplace update the arrays in the typed-dict.
+            move(d)
+
+            print('posx: ', d['posx'])  # Out: posx:  [1.5 0.5 2.7]
+            print('posy: ', d['posy'])  # Out: posy:  [1.7 3.3 2.1]
+            # magictoken.ex_typed_dict_from_cpython.end
+
+        # Test
+        np.testing.assert_array_equal(d['posx'], [1.5, 0.5, 2.7])
+        np.testing.assert_array_equal(d['posy'], [1.7, 3.3, 2.1])
+
+    def test_ex_typed_dict_njit(self):
+        with captured_stdout():
+            # magictoken.ex_typed_dict_njit.begin
+            import numpy as np
+            from numba import njit
+            from numba.core import types
+            from numba.typed import Dict
+
+            # Make array type.  Type-expression is not supported in jit
+            # functions.
+            float_array = types.float64[:]
+
+            @njit
+            def foo():
+                # Make dictionary
+                d = Dict.empty(
+                    key_type=types.unicode_type,
+                    value_type=float_array,
+                )
+                # Fill the dictionary
+                d["posx"] = np.arange(3).astype(np.float64)
+                d["posy"] = np.arange(3, 6).astype(np.float64)
+                return d
+
+            d = foo()
+            # Print the dictionary
+            print(d)  # Out: {posx: [0. 1. 2.], posy: [3. 4. 5.]}
+            # magictoken.ex_typed_dict_njit.end
+        np.testing.assert_array_equal(d['posx'], [0, 1, 2])
+        np.testing.assert_array_equal(d['posy'], [3, 4, 5])
+
+    def test_ex_inferred_dict_njit(self):
+        with captured_stdout():
+            # magictoken.ex_inferred_dict_njit.begin
+            from numba import njit
+            import numpy as np
+
+            @njit
+            def foo():
+                d = dict()
+                k = {1: np.arange(1), 2: np.arange(2)}
+                # The following tells the compiler what the key type and the
+                # value
+                # type are for `d`.
+                d[3] = np.arange(3)
+                d[5] = np.arange(5)
+                return d, k
+
+            d, k = foo()
+            print(d)    # {3: [0 1 2], 5: [0 1 2 3 4]}
+            print(k)    # {1: [0], 2: [0 1]}
+            # magictoken.ex_inferred_dict_njit.end
+        np.testing.assert_array_equal(d[3], [0, 1, 2])
+        np.testing.assert_array_equal(d[5], [0, 1, 2, 3, 4])
+        np.testing.assert_array_equal(k[1], [0])
+        np.testing.assert_array_equal(k[2], [0, 1])
+
+
+if __name__ == '__main__':
+    unittest.main()

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/test_typed_list_usage.py

@@ -0,0 +1,95 @@
+# Contents in this file are referenced from the sphinx-generated docs.
+# "magictoken" is used for markers as beginning and ending of example text.
+
+import unittest
+from numba.tests.support import captured_stdout
+
+
+class DocsTypedListUsageTest(unittest.TestCase):
+
+    def test_ex_inferred_list_jit(self):
+        with captured_stdout():
+
+            # magictoken.ex_inferred_list_jit.begin
+            from numba import njit
+            from numba.typed import List
+
+            @njit
+            def foo():
+                # Instantiate a typed-list
+                l = List()
+                # Append a value to it, this will set the type to int32/int64
+                # (depending on platform)
+                l.append(42)
+                # The usual list operations, getitem, pop and length are
+                # supported
+                print(l[0])   # 42
+                l[0] = 23
+                print(l[0])   # 23
+                print(len(l)) # 1
+                l.pop()
+                print(len(l)) # 0
+                return l
+
+            foo()
+
+            # magictoken.ex_inferred_list_jit.end
+
+    def test_ex_inferred_list(self):
+        with captured_stdout():
+            # magictoken.ex_inferred_list.begin
+            from numba import njit
+            from numba.typed import List
+
+            @njit
+            def foo(mylist):
+                for i in range(10, 20):
+                    mylist.append(i)
+                return mylist
+
+            # Instantiate a typed-list, outside of a jit context
+            l = List()
+            # Append a value to it, this will set the type to int32/int64
+            # (depending on platform)
+            l.append(42)
+            # The usual list operations, getitem, pop and length are supported
+            print(l[0])   # 42
+            l[0] = 23
+            print(l[0])   # 23
+            print(len(l)) # 1
+            l.pop()
+            print(len(l)) # 0
+
+            # And you can use the typed-list as an argument for a jit compiled
+            # function
+            l = foo(l)
+            print(len(l)) # 10
+
+            # You can also directly construct a typed-list from an existing
+            # Python list
+            py_list = [2, 3, 5]
+            numba_list = List(py_list)
+            print(len(numba_list)) # 3
+
+            # magictoken.ex_inferred_list.end
+
+    def test_ex_nested_list(self):
+        with captured_stdout():
+            # magictoken.ex_nested_list.begin
+            from numba.typed import List
+
+            # typed-lists can be nested in typed-lists
+            mylist = List()
+            for i in range(10):
+                l = List()
+                for i in range(10):
+                    l.append(i)
+                mylist.append(l)
+            # mylist is now a list of 10 lists, each containing 10 integers
+            print(mylist)
+
+            # magictoken.ex_nested_list.end
+
+
+if __name__ == '__main__':
+    unittest.main()

.venv/lib/python3.11/site-packages/numba/tests/doc_examples/test_typed_set_usage.py

@@ -0,0 +1,45 @@
+# Contents in this file are referenced from the sphinx-generated docs.
+# "magictoken" is used for markers as beginning and ending of example text.
+
+import unittest
+from numba.tests.support import captured_stdout
+
+
+class DocsTypedSetUsageTest(unittest.TestCase):
+
+    def test_ex_typed_set_from_cpython(self):
+        with captured_stdout():
+            # magictoken.ex_typed_set_from_cpython.begin
+            import numpy as np
+            from numba import njit
+            from numba.core import types
+            from numba.typed import Set
+
+            # The Set.empty() constructs a typed set.
+            # The key typed must be explicitly declared.
+            s = Set.empty(types.unicode_type)
+
+            # The typed-set can be used from the interpreter.
+            s.add("One")
+            s.add("Two")
+            s.add("Three")
+
+            # Here's a function that expects a typed-set as the argument
+            @njit
+            def remove_elem(s, elem):
+                s.discard(elem)
+
+            print(len(s))  # Out: 3
+
+            # Call remove_elem(s) to remove an element in the typed-set.
+            remove_elem(s, "Three")
+
+            print(len(s))  # Out: 2
+            # magictoken.ex_typed_set_from_cpython.end
+
+        # Test
+        np.testing.assert_equal(len(s), 2)
+
+
+if __name__ == '__main__':
+    unittest.main()

.venv/lib/python3.11/site-packages/numba/tests/doctest_usecase.py

@@ -0,0 +1,31 @@
+"""
+Test that all docstrings are the same:
+
+>>> len({f.__doc__ for f in (a, b, c, d)})
+1
+"""
+from numba import guvectorize, int64, njit, vectorize
+
+
+def a():
+    """>>> x = 1"""
+    return 1
+
+
+@njit
+def b():
+    """>>> x = 1"""
+    return 1
+
+
+@guvectorize([(int64[:], int64, int64[:])], "(n),()->(n)")
+def c(x, y, res):
+    """>>> x = 1"""
+    for i in range(x.shape[0]):
+        res[i] = x[i] + y
+
+
+@vectorize([int64(int64, int64)])
+def d(x, y):
+    """>>> x = 1"""
+    return x + y