pool/python-numba
SHA256
2
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
2423598e6c
python-numba/py313.patch

4128 lines
145 KiB
Diff
Raw Normal View History

- Add upstream py313.patch to support Python 3.13 OBS-URL: https://build.opensuse.org/package/show/devel:languages:python:numeric/python-numba?expand=0&rev=98
2024-11-22 12:22:11 +01:00
From 3e89582a41fc2712a0ce86528be98cf3dd768a23 Mon Sep 17 00:00:00 2001
From: Siu Kwan Lam <1929845+sklam@users.noreply.github.com>
Date: Tue, 16 Jan 2024 14:31:01 -0600
Subject: [PATCH 01/61] Minimal changes to get compiling
Added pythoncapi_compat.h from https://github.com/python/pythoncapi-compat
---
numba/_devicearray.cpp | 2 +-
numba/_dispatcher.cpp | 8 +-
numba/_dynfunc.c | 12 +-
numba/_helperlib.c | 4 +-
numba/_pymodule.h | 4 +
numba/_typeof.cpp | 8 +
numba/core/runtime/_nrt_python.c | 2 +-
numba/experimental/jitclass/_box.c | 2 +-
numba/mviewbuf.c | 2 +-
numba/np/ufunc/_internal.c | 4 +-
numba/pythoncapi_compat.h | 1114 ++++++++++++++++++++++++++++
setup.py | 2 +-
12 files changed, 1148 insertions(+), 16 deletions(-)
create mode 100644 numba/pythoncapi_compat.h
Index: numba-0.60.0/numba/_devicearray.cpp
===================================================================
--- numba-0.60.0.orig/numba/_devicearray.cpp
+++ numba-0.60.0/numba/_devicearray.cpp
@@ -96,7 +96,7 @@ PyTypeObject DeviceArrayType = {
/* WARNING: Do not remove this, only modify it! It is a version guard to
* act as a reminder to update this struct on Python version update! */
#if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
#error "Python minor version is not supported."
#endif
#else
Index: numba-0.60.0/numba/_dispatcher.cpp
===================================================================
--- numba-0.60.0.orig/numba/_dispatcher.cpp
+++ numba-0.60.0/numba/_dispatcher.cpp
@@ -27,7 +27,7 @@
*
*/
-#if (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION == 12)
+#if (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION == 12) || (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION == 13)
#ifndef Py_BUILD_CORE
#define Py_BUILD_CORE 1
@@ -39,7 +39,10 @@
# undef HAVE_STD_ATOMIC
#endif
#undef _PyGC_FINALIZED
-#include "internal/pycore_atomic.h"
+
+#if (PY_MINOR_VERSION == 12)
+ #include "internal/pycore_atomic.h"
+#endif
#include "internal/pycore_interp.h"
#include "internal/pycore_pyerrors.h"
#include "internal/pycore_instruments.h"
@@ -780,7 +783,7 @@ call_cfunc(Dispatcher *self, PyObject *c
}
}
-#elif (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION == 12)
+#elif (PY_MAJOR_VERSION >= 3) && ((PY_MINOR_VERSION == 12) || (PY_MINOR_VERSION == 13))
// Python 3.12 has a completely new approach to tracing and profiling due to
// the new `sys.monitoring` system.
@@ -1589,7 +1592,7 @@ static PyTypeObject DispatcherType = {
0, /* tp_version_tag */
0, /* tp_finalize */
0, /* tp_vectorcall */
-#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12)
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12) || (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION == 13)
/* This was introduced first in 3.12
* https://github.com/python/cpython/issues/91051
*/
@@ -1599,7 +1602,7 @@ static PyTypeObject DispatcherType = {
/* WARNING: Do not remove this, only modify it! It is a version guard to
* act as a reminder to update this struct on Python version update! */
#if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
#error "Python minor version is not supported."
#endif
#else
Index: numba-0.60.0/numba/_dynfunc.c
===================================================================
--- numba-0.60.0.orig/numba/_dynfunc.c
+++ numba-0.60.0/numba/_dynfunc.c
@@ -7,6 +7,12 @@
#include <string.h>
+
+// if python version is 3.13
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 13)
+ #include "pythoncapi_compat.h"
+ #define _Py_IsFinalizing Py_IsFinalizing
+#endif
/* NOTE: EnvironmentObject and ClosureObject must be kept in sync with
* the definitions in numba/targets/base.py (EnvBody and ClosureBody).
*/
@@ -146,7 +152,7 @@ static PyTypeObject EnvironmentType = {
/* WARNING: Do not remove this, only modify it! It is a version guard to
* act as a reminder to update this struct on Python version update! */
#if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
#error "Python minor version is not supported."
#endif
#else
@@ -265,7 +271,7 @@ static PyTypeObject ClosureType = {
/* WARNING: Do not remove this, only modify it! It is a version guard to
* act as a reminder to update this struct on Python version update! */
#if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
#error "Python minor version is not supported."
#endif
#else
@@ -485,7 +491,7 @@ static PyTypeObject GeneratorType = {
/* WARNING: Do not remove this, only modify it! It is a version guard to
* act as a reminder to update this struct on Python version update! */
#if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
#error "Python minor version is not supported."
#endif
#else
Index: numba-0.60.0/numba/_helperlib.c
===================================================================
--- numba-0.60.0.orig/numba/_helperlib.c
+++ numba-0.60.0/numba/_helperlib.c
@@ -293,7 +293,7 @@ numba_recreate_record(void *pdata, int s
return NULL;
}
- numpy = PyImport_ImportModuleNoBlock("numpy");
+ numpy = PyImport_ImportModule("numpy");
if (!numpy) goto CLEANUP;
numpy_record = PyObject_GetAttrString(numpy, "record");
@@ -833,7 +833,7 @@ static void traceback_add(const char *fu
if (!frame)
goto error;
-#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12) /* 3.12 */
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12) || (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 13) /* 3.12 or 3.13 */
#elif (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 11) /* 3.11 */
/* unsafe cast to our copy of _frame to access the f_lineno field */
@@ -851,7 +851,7 @@ static void traceback_add(const char *fu
Py_DECREF(frame);
return;
-#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12) /* 3.12 */
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12) || (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 13) /* 3.12 or 3.13 */
error:
_PyErr_ChainExceptions1(exc);
#elif (PY_MAJOR_VERSION == 3) && ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11)) /* 3.11 and below */
Index: numba-0.60.0/numba/_pymodule.h
===================================================================
--- numba-0.60.0.orig/numba/_pymodule.h
+++ numba-0.60.0/numba/_pymodule.h
@@ -29,4 +29,7 @@
PyObject_SetAttrString(m, #name, tmp); \
Py_DECREF(tmp); } while (0)
+
+#define NB_SUPPORTED_PYTHON_MINOR ((PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12) || (PY_MINOR_VERSION == 13))
+
#endif /* NUMBA_PY_MODULE_H_ */
Index: numba-0.60.0/numba/_typeof.cpp
===================================================================
--- numba-0.60.0.orig/numba/_typeof.cpp
+++ numba-0.60.0/numba/_typeof.cpp
@@ -16,6 +16,14 @@
#include <numpy/npy_2_compat.h>
#endif
+#if (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION == 13)
+ #ifndef Py_BUILD_CORE
+ #define Py_BUILD_CORE 1
+ #endif
+ #include "internal/pycore_setobject.h" // _PySet_NextEntry()
+#endif
+
+
/* Cached typecodes for basic scalar types */
static int tc_int8;
static int tc_int16;
Index: numba-0.60.0/numba/core/runtime/_nrt_python.c
===================================================================
--- numba-0.60.0.orig/numba/core/runtime/_nrt_python.c
+++ numba-0.60.0/numba/core/runtime/_nrt_python.c
@@ -229,7 +229,7 @@ static PyTypeObject MemInfoType = {
/* WARNING: Do not remove this, only modify it! It is a version guard to
* act as a reminder to update this struct on Python version update! */
#if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
#error "Python minor version is not supported."
#endif
#else
Index: numba-0.60.0/numba/experimental/jitclass/_box.c
===================================================================
--- numba-0.60.0.orig/numba/experimental/jitclass/_box.c
+++ numba-0.60.0/numba/experimental/jitclass/_box.c
@@ -110,7 +110,7 @@ static PyTypeObject BoxType = {
/* WARNING: Do not remove this, only modify it! It is a version guard to
* act as a reminder to update this struct on Python version update! */
#if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
#error "Python minor version is not supported."
#endif
#else
Index: numba-0.60.0/numba/mviewbuf.c
===================================================================
--- numba-0.60.0.orig/numba/mviewbuf.c
+++ numba-0.60.0/numba/mviewbuf.c
@@ -344,7 +344,7 @@ static PyTypeObject MemAllocType = {
/* WARNING: Do not remove this, only modify it! It is a version guard to
* act as a reminder to update this struct on Python version update! */
#if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
#error "Python minor version is not supported."
#endif
#else
Index: numba-0.60.0/numba/np/ufunc/_internal.c
===================================================================
--- numba-0.60.0.orig/numba/np/ufunc/_internal.c
+++ numba-0.60.0/numba/np/ufunc/_internal.c
@@ -100,7 +100,7 @@ PyTypeObject PyUFuncCleaner_Type = {
/* WARNING: Do not remove this, only modify it! It is a version guard to
* act as a reminder to update this struct on Python version update! */
#if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
#error "Python minor version is not supported."
#endif
#else
@@ -753,7 +753,7 @@ PyTypeObject PyDUFunc_Type = {
/* WARNING: Do not remove this, only modify it! It is a version guard to
* act as a reminder to update this struct on Python version update! */
#if (PY_MAJOR_VERSION == 3)
-#if ! ((PY_MINOR_VERSION == 9) || (PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12))
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
#error "Python minor version is not supported."
#endif
#else
Index: numba-0.60.0/numba/core/bytecode.py
===================================================================
--- numba-0.60.0.orig/numba/core/bytecode.py
+++ numba-0.60.0/numba/core/bytecode.py
@@ -9,7 +9,7 @@ from numba.core import errors, utils, se
from numba.core.utils import PYVERSION
-if PYVERSION in ((3, 12), ):
+if PYVERSION in ((3, 12), (3, 13)):
from opcode import _inline_cache_entries
# Instruction/opcode length in bytes
INSTR_LEN = 2
@@ -104,7 +104,12 @@ class ByteCodeInst(object):
# https://bugs.python.org/issue27129
# https://github.com/python/cpython/pull/25069
assert self.is_jump
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 13),):
+ if self.opcode in (dis.opmap[k]
+ for k in ["JUMP_BACKWARD",
+ "JUMP_BACKWARD_NO_INTERRUPT"]):
+ return self.next - (self.arg * 2)
+ elif PYVERSION in ((3, 12),):
if self.opcode in (dis.opmap[k]
for k in ["JUMP_BACKWARD"]):
return self.offset - (self.arg - 1) * 2
@@ -121,7 +126,7 @@ class ByteCodeInst(object):
else:
raise NotImplementedError(PYVERSION)
- if PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ if PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
if self.opcode in JREL_OPS:
return self.next + self.arg * 2
else:
@@ -160,7 +165,7 @@ OPCODE_NOP = dis.opname.index('NOP')
# Adapted from Lib/dis.py
-def _unpack_opargs(code):
+def _unpack_opargs_pre_3_13(code):
"""
Returns a 4-int-tuple of
(bytecode offset, opcode, argument, offset of next bytecode).
@@ -176,7 +181,7 @@ def _unpack_opargs(code):
for j in range(ARG_LEN):
arg |= code[i + j] << (8 * j)
i += ARG_LEN
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12),):
# Python 3.12 introduced cache slots. We need to account for
# cache slots when we determine the offset of the next opcode.
# The number of cache slots is specific to each opcode and can
@@ -200,7 +205,7 @@ def _unpack_opargs(code):
else:
arg = None
i += NO_ARG_LEN
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12),):
# Python 3.12 introduced cache slots. We need to account for
# cache slots when we determine the offset of the next opcode.
# The number of cache slots is specific to each opcode and can
@@ -216,6 +221,80 @@ def _unpack_opargs(code):
offset = i # Mark inst offset at first extended
+# Adapted from Lib/dis.py
+def _unpack_opargs_pre_3_13(code):
+ """
+ Returns a 4-int-tuple of
+ (bytecode offset, opcode, argument, offset of next bytecode).
+ """
+ extended_arg = 0
+ n = len(code)
+ offset = i = 0
+ while i < n:
+ op = code[i]
+ i += CODE_LEN
+ if op >= HAVE_ARGUMENT:
+ arg = code[i] | extended_arg
+ for j in range(ARG_LEN):
+ arg |= code[i + j] << (8 * j)
+ i += ARG_LEN
+ if PYVERSION in ((3, 12),):
+ # Python 3.12 introduced cache slots. We need to account for
+ # cache slots when we determine the offset of the next opcode.
+ # The number of cache slots is specific to each opcode and can
+ # be looked up in the _inline_cache_entries dictionary.
+ i += _inline_cache_entries[op] * INSTR_LEN
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+ if op == EXTENDED_ARG:
+ # This is a deviation from what dis does...
+ # In python 3.11 it seems like EXTENDED_ARGs appear more often
+ # and are also used as jump targets. So as to not have to do
+ # "book keeping" for where EXTENDED_ARGs have been "skipped"
+ # they are replaced with NOPs so as to provide a legal jump
+ # target and also ensure that the bytecode offsets are correct.
+ yield (offset, OPCODE_NOP, arg, i)
+ extended_arg = arg << 8 * ARG_LEN
+ offset = i
+ continue
+ else:
+ arg = None
+ i += NO_ARG_LEN
+ if PYVERSION in ((3, 12),):
+ # Python 3.12 introduced cache slots. We need to account for
+ # cache slots when we determine the offset of the next opcode.
+ # The number of cache slots is specific to each opcode and can
+ # be looked up in the _inline_cache_entries dictionary.
+ i += _inline_cache_entries[op] * INSTR_LEN
+ elif PYVERSION in ((3, 10), (3, 11)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ extended_arg = 0
+ yield (offset, op, arg, i)
+ offset = i # Mark inst offset at first extended
+
+
+if PYVERSION in ((3, 13),):
+
+ def _unpack_opargs(code):
+ buf = []
+ for i, start_offset, op, arg in dis._unpack_opargs(code):
+ buf.append((start_offset, op, arg))
+ for i, (start_offset, op, arg) in enumerate(buf):
+ if i + 1 < len(buf):
+ next_offset = buf[i + 1][0]
+ else:
+ next_offset = len(code)
+ yield (start_offset, op, arg, next_offset)
+
+else:
+ _unpack_opargs = _unpack_opargs_pre_3_13
+
+
def _patched_opargs(bc_stream):
"""Patch the bytecode stream.
@@ -298,7 +377,7 @@ class _ByteCode(object):
# Start with first bytecode's lineno
known = code.co_firstlineno
for inst in table.values():
- if inst.lineno >= 0:
+ if inst.lineno is not None and inst.lineno >= 0:
known = inst.lineno
else:
inst.lineno = known
@@ -363,7 +442,7 @@ class _ByteCode(object):
def _fix_LOAD_GLOBAL_arg(arg):
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
return arg >> 1
elif PYVERSION in ((3, 9), (3, 10)):
return arg
@@ -452,8 +531,15 @@ class ByteCodePy312(ByteCodePy311):
entirely along with the dead exceptions that it points to.
A pair of exception that sandwiches these exception will
also be merged into a single exception.
- """
+ Update for Python 3.13, the ending of the pattern has a extra
+ POP_TOP:
+
+ ...
+ END_FOR
+ POP_TOP
+ SWAP(2)
+ """
def pop_and_merge_exceptions(entries: list,
entry_to_remove: _ExceptionTableEntry):
lower_entry_idx = entries.index(entry_to_remove) - 1
@@ -505,17 +591,34 @@ class ByteCodePy312(ByteCodePy311):
if not next_inst.opname == "FOR_ITER":
continue
- # Check end of pattern, two instructions.
- # Check for the corresponding END_FOR, exception table end is
- # non-inclusive, so subtract one.
- index = self.ordered_offsets.index(entry.end)
- curr_inst = self.table[self.ordered_offsets[index - 1]]
- if not curr_inst.opname == "END_FOR":
- continue
- # END_FOR must be followed by SWAP(2)
- next_inst = self.table[self.ordered_offsets[index]]
- if not next_inst.opname == "SWAP" and next_inst.arg == 2:
- continue
+ if PYVERSION == (3, 13):
+ # Check end of pattern, two instructions.
+ # Check for the corresponding END_FOR, exception table end
+ # is non-inclusive, so subtract one.
+ index = self.ordered_offsets.index(entry.end)
+ curr_inst = self.table[self.ordered_offsets[index - 2]]
+ if not curr_inst.opname == "END_FOR":
+ continue
+ next_inst = self.table[self.ordered_offsets[index - 1]]
+ if not next_inst.opname == "POP_TOP":
+ continue
+ # END_FOR must be followed by SWAP(2)
+ next_inst = self.table[self.ordered_offsets[index]]
+ if not next_inst.opname == "SWAP" and next_inst.arg == 2:
+ continue
+ else:
+ assert PYVERSION < (3, 13)
+ # Check end of pattern, two instructions.
+ # Check for the corresponding END_FOR, exception table end
+ # is non-inclusive, so subtract one.
+ index = self.ordered_offsets.index(entry.end)
+ curr_inst = self.table[self.ordered_offsets[index - 1]]
+ if not curr_inst.opname == "END_FOR":
+ continue
+ # END_FOR must be followed by SWAP(2)
+ next_inst = self.table[self.ordered_offsets[index]]
+ if not next_inst.opname == "SWAP" and next_inst.arg == 2:
+ continue
# If all conditions are met that means this exception entry
# is for a list/dict/set comprehension and can be removed.
# Also if there exist exception entries above and below this
@@ -528,7 +631,7 @@ class ByteCodePy312(ByteCodePy311):
if PYVERSION == (3, 11):
ByteCode = ByteCodePy311
-elif PYVERSION == (3, 12):
+elif PYVERSION in ((3, 12), (3, 13),):
ByteCode = ByteCodePy312
elif PYVERSION < (3, 11):
ByteCode = _ByteCode
Index: numba-0.60.0/numba/core/byteflow.py
===================================================================
--- numba-0.60.0.orig/numba/core/byteflow.py
+++ numba-0.60.0/numba/core/byteflow.py
@@ -10,7 +10,7 @@ from functools import total_ordering
from numba.core.utils import UniqueDict, PYVERSION, ALL_BINOPS_TO_OPERATORS
from numba.core.controlflow import NEW_BLOCKERS, CFGraph
from numba.core.ir import Loc
-from numba.core.errors import UnsupportedError
+from numba.core.errors import UnsupportedBytecodeError
_logger = logging.getLogger(__name__)
@@ -24,7 +24,7 @@ _NO_RAISE_OPS = frozenset({
'PRECALL',
})
-if PYVERSION in ((3, 12), ):
+if PYVERSION in ((3, 12), (3, 13)):
from enum import Enum
# Operands for CALL_INTRINSIC_1
@@ -149,7 +149,7 @@ class Flow(object):
self.block_infos[state.pc_initial] = si = adapt_state_infos(state)
_logger.debug("block_infos %s:\n%s", state, si)
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
def _run_handle_exception(self, runner, state):
if not state.in_with() and (
state.has_active_try() and
@@ -312,7 +312,7 @@ class Flow(object):
msg = ("The 'with (context manager) as "
"(variable):' construct is not "
"supported.")
- raise UnsupportedError(msg)
+ raise UnsupportedBytecodeError(msg)
def _is_null_temp_reg(reg):
@@ -331,7 +331,7 @@ class TraceRunner(object):
return Loc(self.debug_filename, lineno)
def dispatch(self, state):
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
if state._blockstack:
state: State
while state._blockstack:
@@ -354,7 +354,8 @@ class TraceRunner(object):
fn(state, inst)
else:
msg = "Use of unsupported opcode (%s) found" % inst.opname
- raise UnsupportedError(msg, loc=self.get_debug_loc(inst.lineno))
+ raise UnsupportedBytecodeError(msg,
+ loc=self.get_debug_loc(inst.lineno))
def _adjust_except_stack(self, state):
"""
@@ -405,6 +406,15 @@ class TraceRunner(object):
state.push(state.make_temp())
state.append(inst)
+ if PYVERSION in ((3, 13),):
+ def op_FORMAT_SIMPLE(self, state, inst):
+ assert PYVERSION == (3, 13)
+ value = state.pop()
+ strvar = state.make_temp()
+ res = state.make_temp()
+ state.append(inst, value=value, res=res, strvar=strvar)
+ state.push(res)
+
def op_FORMAT_VALUE(self, state, inst):
"""
FORMAT_VALUE(flags): flags argument specifies format spec which is
@@ -415,7 +425,8 @@ class TraceRunner(object):
"""
if inst.arg != 0:
msg = "format spec in f-strings not supported yet"
- raise UnsupportedError(msg, loc=self.get_debug_loc(inst.lineno))
+ raise UnsupportedBytecodeError(msg,
+ loc=self.get_debug_loc(inst.lineno))
value = state.pop()
strvar = state.make_temp()
res = state.make_temp()
@@ -442,7 +453,27 @@ class TraceRunner(object):
def op_POP_TOP(self, state, inst):
state.pop()
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 13),):
+ def op_TO_BOOL(self, state, inst):
+ res = state.make_temp()
+ tos = state.pop()
+ state.append(inst, val=tos, res=res)
+ state.push(res)
+
+ elif PYVERSION < (3, 13):
+ pass
+
+ if PYVERSION in ((3, 13),):
+ def op_LOAD_GLOBAL(self, state, inst):
+ # Ordering of the global value and NULL is swapped in Py3.13
+ res = state.make_temp()
+ idx = inst.arg >> 1
+ state.append(inst, idx=idx, res=res)
+ state.push(res)
+ # ignoring the NULL
+ if inst.arg & 1:
+ state.push(state.make_null())
+ elif PYVERSION in ((3, 11), (3, 12)):
def op_LOAD_GLOBAL(self, state, inst):
res = state.make_temp()
idx = inst.arg >> 1
@@ -471,30 +502,89 @@ class TraceRunner(object):
state.push(res)
def op_LOAD_CONST(self, state, inst):
- res = state.make_temp("const")
+ # append const index for interpreter to read the const value
+ res = state.make_temp("const") + f".{inst.arg}"
state.push(res)
state.append(inst, res=res)
def op_LOAD_ATTR(self, state, inst):
item = state.pop()
- if PYVERSION in ((3, 12), ):
+ res = state.make_temp()
+ if PYVERSION in ((3, 13),):
+ state.push(res) # the attr
+ if inst.arg & 1:
+ state.push(state.make_null())
+ elif PYVERSION in ((3, 12),):
if inst.arg & 1:
state.push(state.make_null())
+ state.push(res)
elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
- pass
+ state.push(res)
else:
raise NotImplementedError(PYVERSION)
- res = state.make_temp()
state.append(inst, item=item, res=res)
- state.push(res)
def op_LOAD_FAST(self, state, inst):
- name = state.get_varname(inst)
+ assert PYVERSION <= (3, 13)
+ if PYVERSION in ((3, 13), ):
+ try:
+ name = state.get_varname(inst)
+ except IndexError: # oparg is out of range
+ # Handle this like a LOAD_DEREF
+ # Assume MAKE_CELL and COPY_FREE_VARS has correctly setup the
+ # states.
+ # According to https://github.com/python/cpython/blob/9ac606080a0074cdf7589d9b7c9413a73e0ddf37/Objects/codeobject.c#L730C9-L759 # noqa E501
+ # localsplus is locals + cells + freevars
+ bc = state._bytecode
+ num_varnames = len(bc.co_varnames)
+ num_freevars = len(bc.co_freevars)
+ num_cellvars = len(bc.co_cellvars)
+ max_fast_local = num_cellvars + num_freevars
+ assert 0 <= inst.arg - num_varnames < max_fast_local
+ res = state.make_temp()
+ state.append(inst, res=res, as_load_deref=True)
+ state.push(res)
+ return
+ else:
+ name = state.get_varname(inst)
res = state.make_temp(name)
state.append(inst, res=res)
state.push(res)
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 13),):
+ def op_LOAD_FAST_LOAD_FAST(self, state, inst):
+ oparg = inst.arg
+ oparg1 = oparg >> 4
+ oparg2 = oparg & 15
+ name1 = state.get_varname_by_arg(oparg1)
+ name2 = state.get_varname_by_arg(oparg2)
+ res1 = state.make_temp(name1)
+ res2 = state.make_temp(name2)
+ state.append(inst, res1=res1, res2=res2)
+ state.push(res1)
+ state.push(res2)
+
+ def op_STORE_FAST_LOAD_FAST(self, state, inst):
+ oparg = inst.arg
+ # oparg1 = oparg >> 4 # not needed
+ oparg2 = oparg & 15
+ store_value = state.pop()
+ load_name = state.get_varname_by_arg(oparg2)
+ load_res = state.make_temp(load_name)
+ state.append(inst, store_value=store_value, load_res=load_res)
+ state.push(load_res)
+
+ def op_STORE_FAST_STORE_FAST(self, state, inst):
+ value1 = state.pop()
+ value2 = state.pop()
+ state.append(inst, value1=value1, value2=value2)
+
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ if PYVERSION in ((3, 12), (3, 13)):
op_LOAD_FAST_CHECK = op_LOAD_FAST
op_LOAD_FAST_AND_CLEAR = op_LOAD_FAST
elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
@@ -753,7 +843,7 @@ class TraceRunner(object):
)
state.push(res)
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
def op_BINARY_SLICE(self, state, inst):
end = state.pop()
start = state.pop()
@@ -771,7 +861,7 @@ class TraceRunner(object):
else:
raise NotImplementedError(PYVERSION)
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
def op_STORE_SLICE(self, state, inst):
end = state.pop()
start = state.pop()
@@ -804,7 +894,7 @@ class TraceRunner(object):
op_POP_JUMP_IF_TRUE = _op_POP_JUMP_IF
op_POP_JUMP_IF_FALSE = _op_POP_JUMP_IF
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
op_POP_JUMP_IF_NONE = _op_POP_JUMP_IF
op_POP_JUMP_IF_NOT_NONE = _op_POP_JUMP_IF
elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
@@ -853,6 +943,8 @@ class TraceRunner(object):
state.append(inst)
state.fork(pc=inst.get_jump_target())
+ op_JUMP_BACKWARD_NO_INTERRUPT = op_JUMP_BACKWARD
+
def op_JUMP_ABSOLUTE(self, state, inst):
state.append(inst)
state.fork(pc=inst.get_jump_target())
@@ -868,7 +960,7 @@ class TraceRunner(object):
state.append(inst, retval=state.pop(), castval=state.make_temp())
state.terminate()
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
def op_RETURN_CONST(self, state, inst):
res = state.make_temp("const")
state.append(inst, retval=res, castval=state.make_temp())
@@ -884,14 +976,14 @@ class TraceRunner(object):
state.append(inst, value=val, res=res)
state.push(res)
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
def op_RAISE_VARARGS(self, state, inst):
if inst.arg == 0:
exc = None
# No re-raising within a try-except block.
# But we allow bare reraise.
if state.has_active_try():
- raise UnsupportedError(
+ raise UnsupportedBytecodeError(
"The re-raising of an exception is not yet supported.",
loc=self.get_debug_loc(inst.lineno),
)
@@ -915,7 +1007,7 @@ class TraceRunner(object):
if inst.arg == 0:
exc = None
if in_exc_block:
- raise UnsupportedError(
+ raise UnsupportedBytecodeError(
"The re-raising of an exception is not yet supported.",
loc=self.get_debug_loc(inst.lineno),
)
@@ -940,7 +1032,10 @@ class TraceRunner(object):
blk = state.pop_block()
state.reset_stack(blk['entry_stack'])
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 13),):
+ def op_END_FOR(self, state, inst):
+ state.pop()
+ elif PYVERSION in ((3, 12),):
def op_END_FOR(self, state, inst):
state.pop()
state.pop()
@@ -954,7 +1049,8 @@ class TraceRunner(object):
if inst.arg != 0:
msg = ('Unsupported use of a bytecode related to try..finally'
' or a with-context')
- raise UnsupportedError(msg, loc=self.get_debug_loc(inst.lineno))
+ raise UnsupportedBytecodeError(msg,
+ loc=self.get_debug_loc(inst.lineno))
def op_CALL_FINALLY(self, state, inst):
pass
@@ -1068,7 +1164,7 @@ class TraceRunner(object):
'FINALLY', state, next=inst.next, end=inst.get_jump_target(),
)
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
def op_POP_EXCEPT(self, state, inst):
state.pop()
@@ -1076,7 +1172,7 @@ class TraceRunner(object):
def op_POP_EXCEPT(self, state, inst):
blk = state.pop_block()
if blk['kind'] not in {BlockKind('EXCEPT'), BlockKind('FINALLY')}:
- raise UnsupportedError(
+ raise UnsupportedBytecodeError(
f"POP_EXCEPT got an unexpected block: {blk['kind']}",
loc=self.get_debug_loc(inst.lineno),
)
@@ -1117,16 +1213,24 @@ class TraceRunner(object):
def op_CALL(self, state, inst):
narg = inst.arg
args = list(reversed([state.pop() for _ in range(narg)]))
- callable_or_firstarg = state.pop()
- null_or_callable = state.pop()
- if _is_null_temp_reg(null_or_callable):
- callable = callable_or_firstarg
- else:
- callable = null_or_callable
- args = [callable_or_firstarg, *args]
+ if PYVERSION == (3, 13):
+ null_or_self = state.pop()
+ # position of the callable is fixed
+ callable = state.pop()
+ if not _is_null_temp_reg(null_or_self):
+ args = [null_or_self, *args]
+ kw_names = None
+ elif PYVERSION < (3, 13):
+ callable_or_firstarg = state.pop()
+ null_or_callable = state.pop()
+ if _is_null_temp_reg(null_or_callable):
+ callable = callable_or_firstarg
+ else:
+ callable = null_or_callable
+ args = [callable_or_firstarg, *args]
+ kw_names = state.pop_kw_names()
res = state.make_temp()
- kw_names = state.pop_kw_names()
state.append(inst, func=callable, args=args, kw_names=kw_names, res=res)
state.push(res)
@@ -1152,28 +1256,67 @@ class TraceRunner(object):
state.append(inst, func=func, args=args, names=names, res=res)
state.push(res)
- def op_CALL_FUNCTION_EX(self, state, inst):
- if inst.arg & 1 and PYVERSION < (3, 10):
- errmsg = "CALL_FUNCTION_EX with **kwargs not supported"
- raise UnsupportedError(errmsg)
- if inst.arg & 1:
- varkwarg = state.pop()
- else:
- varkwarg = None
- vararg = state.pop()
- func = state.pop()
+ if PYVERSION in ((3, 13),):
+ def op_CALL_KW(self, state, inst):
+ narg = inst.arg
+ kw_names = state.pop()
+ args = list(reversed([state.pop() for _ in range(narg)]))
+ null_or_firstarg = state.pop()
+ callable = state.pop()
+ if not _is_null_temp_reg(null_or_firstarg):
+ args = [null_or_firstarg, *args]
- if PYVERSION in ((3, 11), (3, 12)):
- if _is_null_temp_reg(state.peek(1)):
- state.pop() # pop NULL, it's not used
- elif PYVERSION in ((3, 9), (3, 10)):
- pass
- else:
- raise NotImplementedError(PYVERSION)
+ res = state.make_temp()
+ state.append(inst, func=callable, args=args, kw_names=kw_names,
+ res=res)
+ state.push(res)
- res = state.make_temp()
- state.append(inst, func=func, vararg=vararg, varkwarg=varkwarg, res=res)
- state.push(res)
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ if PYVERSION in ((3, 13),):
+ def op_CALL_FUNCTION_EX(self, state, inst):
+ # (func, unused, callargs, kwargs if (oparg & 1) -- result))
+ if inst.arg & 1:
+ varkwarg = state.pop()
+ else:
+ varkwarg = None
+
+ vararg = state.pop()
+ state.pop() # unused
+ func = state.pop()
+
+ res = state.make_temp()
+ state.append(inst, func=func, vararg=vararg, varkwarg=varkwarg,
+ res=res)
+ state.push(res)
+
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+
+ def op_CALL_FUNCTION_EX(self, state, inst):
+ if inst.arg & 1:
+ varkwarg = state.pop()
+ else:
+ varkwarg = None
+ vararg = state.pop()
+ func = state.pop()
+
+ if PYVERSION in ((3, 11), (3, 12)):
+ if _is_null_temp_reg(state.peek(1)):
+ state.pop() # pop NULL, it's not used
+ elif PYVERSION in ((3, 9), (3, 10)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ res = state.make_temp()
+ state.append(inst, func=func, vararg=vararg, varkwarg=varkwarg,
+ res=res)
+ state.push(res)
+ else:
+ raise NotImplementedError(PYVERSION)
def _dup_topx(self, state, inst, count):
orig = [state.pop() for _ in range(count)]
@@ -1187,7 +1330,7 @@ class TraceRunner(object):
for val in duped:
state.push(val)
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
def op_CALL_INTRINSIC_1(self, state, inst):
# See https://github.com/python/cpython/blob/v3.12.0rc2/Include/
# internal/pycore_intrinsics.h#L3-L17C36
@@ -1404,7 +1547,7 @@ class TraceRunner(object):
pred=pred)
state.push(indval)
end = inst.get_jump_target()
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
# Changed in version 3.12: Up until 3.11 the iterator was
# popped when it was exhausted. Now this is handled using END_FOR
# op code.
@@ -1490,7 +1633,7 @@ class TraceRunner(object):
op_BINARY_XOR = _binaryop
def op_MAKE_FUNCTION(self, state, inst, MAKE_CLOSURE=False):
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
# https://github.com/python/cpython/commit/2f180ce
# name set via co_qualname
name = None
@@ -1500,14 +1643,19 @@ class TraceRunner(object):
raise NotImplementedError(PYVERSION)
code = state.pop()
closure = annotations = kwdefaults = defaults = None
- if inst.arg & 0x8:
- closure = state.pop()
- if inst.arg & 0x4:
- annotations = state.pop()
- if inst.arg & 0x2:
- kwdefaults = state.pop()
- if inst.arg & 0x1:
- defaults = state.pop()
+ if PYVERSION in ((3, 13), ):
+ assert inst.arg is None
+ # SET_FUNCTION_ATTRIBUTE is responsible for setting
+ # closure, annotations, kwdefaults and defaults.
+ else:
+ if inst.arg & 0x8:
+ closure = state.pop()
+ if inst.arg & 0x4:
+ annotations = state.pop()
+ if inst.arg & 0x2:
+ kwdefaults = state.pop()
+ if inst.arg & 0x1:
+ defaults = state.pop()
res = state.make_temp()
state.append(
inst,
@@ -1521,6 +1669,27 @@ class TraceRunner(object):
)
state.push(res)
+ def op_SET_FUNCTION_ATTRIBUTE(self, state, inst):
+ assert PYVERSION in ((3, 13), )
+ make_func_stack = state.pop()
+ data = state.pop()
+ if inst.arg == 0x1:
+ # 0x01 a tuple of default values for positional-only and
+ # positional-or-keyword parameters in positional order
+ state.set_function_attribute(make_func_stack, defaults=data)
+ elif inst.arg & 0x2:
+ # 0x02 a tuple of strings containing parameters’ annotations
+ state.set_function_attribute(make_func_stack, kwdefaults=data)
+ elif inst.arg & 0x4:
+ # 0x04 a tuple of strings containing parameters’ annotations
+ state.set_function_attribute(make_func_stack, annotations=data)
+ elif inst.arg == 0x8:
+ # 0x08 a tuple containing cells for free variables, making a closure
+ state.set_function_attribute(make_func_stack, closure=data)
+ else:
+ raise AssertionError("unreachable")
+ state.push(make_func_stack)
+
def op_MAKE_CLOSURE(self, state, inst):
self.op_MAKE_FUNCTION(state, inst, MAKE_CLOSURE=True)
@@ -1551,7 +1720,7 @@ class TraceRunner(object):
state.fork(pc=inst.next)
state.fork(pc=inst.get_jump_target())
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
def op_RERAISE(self, state, inst):
# This isn't handled, but the state is set up anyway
exc = state.pop()
@@ -1576,7 +1745,7 @@ class TraceRunner(object):
# NOTE: Please see notes in `interpreter.py` surrounding the implementation
# of LOAD_METHOD and CALL_METHOD.
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
# LOAD_METHOD has become a pseudo-instruction in 3.12
pass
elif PYVERSION in ((3, 11), ):
@@ -1828,9 +1997,14 @@ class _State(object):
return self.get_top_block('TRY') is not None
def get_varname(self, inst):
+ """Get referenced variable name from the instruction's oparg
+ """
+ return self.get_varname_by_arg(inst.arg)
+
+ def get_varname_by_arg(self, oparg: int):
"""Get referenced variable name from the oparg
"""
- return self._bytecode.co_varnames[inst.arg]
+ return self._bytecode.co_varnames[oparg]
def terminate(self):
"""Mark block as terminated
@@ -1852,7 +2026,7 @@ class _State(object):
stack.append(self.make_temp())
# Handle changes on the blockstack
blockstack = list(self._blockstack)
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
# pop expired block in destination pc
while blockstack:
top = blockstack[-1]
@@ -1940,7 +2114,21 @@ class StatePy311(_State):
return self.make_temp(prefix="null$")
-if PYVERSION >= (3, 11):
+class StatePy313(StatePy311):
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
+ self._make_func_attrs = defaultdict(dict)
+
+ def set_function_attribute(self, make_func_res, **kwargs):
+ self._make_func_attrs[make_func_res].update(kwargs)
+
+ def get_function_attributes(self, make_func_res):
+ return self._make_func_attrs[make_func_res]
+
+
+if PYVERSION in ((3, 13), ):
+ State = StatePy313
+elif PYVERSION in ((3, 11), (3, 12)):
State = StatePy311
elif PYVERSION < (3, 11):
State = _State
@@ -1970,8 +2158,20 @@ AdaptBlockInfo = namedtuple(
def adapt_state_infos(state):
+ def process_function_attributes(inst_pair):
+ offset, data = inst_pair
+ inst = state._bytecode[offset]
+ if inst.opname == "MAKE_FUNCTION":
+ data.update(state.get_function_attributes(data['res']))
+ return offset, data
+ if PYVERSION in ((3, 13), ):
+ insts = tuple(map(process_function_attributes, state.instructions))
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ insts = tuple(state.instructions)
+ else:
+ raise NotImplementedError(PYVERSION)
return AdaptBlockInfo(
- insts=tuple(state.instructions),
+ insts=insts,
outgoing_phis=state.outgoing_phis,
blockstack=state.blockstack_initial,
active_try_block=state.find_initial_try_block(),
Index: numba-0.60.0/numba/core/controlflow.py
===================================================================
--- numba-0.60.0.orig/numba/core/controlflow.py
+++ numba-0.60.0/numba/core/controlflow.py
@@ -954,7 +954,7 @@ class ControlFlowAnalysis(object):
self._curblock.terminating = True
self._force_new_block = True
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
def op_RETURN_CONST(self, inst):
self._curblock.terminating = True
self._force_new_block = True
Index: numba-0.60.0/numba/core/interpreter.py
===================================================================
--- numba-0.60.0.orig/numba/core/interpreter.py
+++ numba-0.60.0/numba/core/interpreter.py
@@ -6,7 +6,11 @@ import logging
import textwrap
from numba.core import errors, ir, config
-from numba.core.errors import NotDefinedError, UnsupportedError, error_extras
+from numba.core.errors import (
+ NotDefinedError,
+ UnsupportedBytecodeError,
+ error_extras,
+)
from numba.core.ir_utils import get_definition, guard
from numba.core.utils import (PYVERSION, BINOPS_TO_OPERATORS,
INPLACE_BINOPS_TO_OPERATORS,)
@@ -15,7 +19,7 @@ from numba.core.unsafe import eh
from numba.cpython.unsafe.tuple import unpack_single_tuple
-if PYVERSION in ((3, 12), ):
+if PYVERSION in ((3, 12), (3, 13)):
# Operands for CALL_INTRINSIC_1
from numba.core.byteflow import CALL_INTRINSIC_1_Operand as ci1op
elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
@@ -108,7 +112,7 @@ def _remove_assignment_definition(old_bo
func_ir._definitions[lhs].remove(rhs)
already_deleted_defs[lhs].add(rhs)
elif rhs not in already_deleted_defs[lhs]:
- raise UnsupportedError(
+ raise UnsupportedBytecodeError(
"Inconsistency found in the definitions while executing"
" a peephole optimization. This suggests an internal"
" error or inconsistency elsewhere in the compiler."
@@ -211,7 +215,7 @@ def _call_function_ex_replace_kws_large(
):
# We cannot handle this format so raise the
# original error message.
- raise UnsupportedError(errmsg)
+ raise UnsupportedBytecodeError(errmsg)
key_var_name = const_stmt.target.name
key_val = const_stmt.value.value
search_start += 1
@@ -257,7 +261,7 @@ def _call_function_ex_replace_kws_large(
):
# We cannot handle this format so raise the
# original error message.
- raise UnsupportedError(errmsg)
+ raise UnsupportedBytecodeError(errmsg)
setitem_stmt = old_body[search_start + 1]
if not (
isinstance(setitem_stmt, ir.Assign)
@@ -277,7 +281,7 @@ def _call_function_ex_replace_kws_large(
# getattr. If for some reason this doesn't match the code
# format, we raise the original error message. This check
# is meant as a precaution.
- raise UnsupportedError(errmsg)
+ raise UnsupportedBytecodeError(errmsg)
arg_var = setitem_stmt.value.args[1]
# Append the (key, value) pair.
kws.append((key_val, arg_var))
@@ -421,7 +425,7 @@ def _call_function_ex_replace_args_large
and concat_stmt.value.fn == operator.add
):
# We cannot handle this format.
- raise UnsupportedError(errmsg)
+ raise UnsupportedBytecodeError(errmsg)
lhs_name = concat_stmt.value.lhs.name
rhs_name = concat_stmt.value.rhs.name
# The previous statement should be a
@@ -439,7 +443,7 @@ def _call_function_ex_replace_args_large
and len(arg_tuple_stmt.value.items) == 1
):
# We cannot handle this format.
- raise UnsupportedError(errmsg)
+ raise UnsupportedBytecodeError(errmsg)
if arg_tuple_stmt.target.name == lhs_name:
# The tuple should always be generated on the RHS.
raise AssertionError("unreachable")
@@ -447,7 +451,7 @@ def _call_function_ex_replace_args_large
target_name = lhs_name
else:
# We cannot handle this format.
- raise UnsupportedError(errmsg)
+ raise UnsupportedBytecodeError(errmsg)
total_args.append(
arg_tuple_stmt.value.items[0]
)
@@ -497,7 +501,7 @@ def _call_function_ex_replace_args_large
# If we reached the start we never found the build_tuple.
# We cannot handle this format so raise the
# original error message.
- raise UnsupportedError(errmsg)
+ raise UnsupportedBytecodeError(errmsg)
# Reverse the arguments so we get the correct order.
return total_args[::-1]
@@ -586,7 +590,7 @@ def peep_hole_call_function_ex_to_call_f
# If we couldn't find where the kwargs are created
# then it should be a normal **kwargs call
# so we produce an unsupported message.
- raise UnsupportedError(errmsg)
+ raise UnsupportedBytecodeError(errmsg)
# Determine the kws
if keyword_def.value.items:
# n_kws <= 15 case.
@@ -638,7 +642,7 @@ def peep_hole_call_function_ex_to_call_f
if args:
# If we have vararg then args is expected to
# be an empty list.
- raise UnsupportedError(errmsg)
+ raise UnsupportedBytecodeError(errmsg)
vararg_loc = start_search
args_def = None
found = False
@@ -654,7 +658,7 @@ def peep_hole_call_function_ex_to_call_f
if not found:
# If we couldn't find where the args are created
# then we can't handle this format.
- raise UnsupportedError(errmsg)
+ raise UnsupportedBytecodeError(errmsg)
if (
isinstance(args_def.value, ir.Expr)
and args_def.value.op == "build_tuple"
@@ -683,7 +687,7 @@ def peep_hole_call_function_ex_to_call_f
# If there is a call with vararg we need to check
# if the list -> tuple conversion failed and if so
# throw an error.
- raise UnsupportedError(errmsg)
+ raise UnsupportedBytecodeError(errmsg)
else:
# Here the IR is an initial empty build_tuple.
# Then for each arg, a new tuple with a single
@@ -747,7 +751,7 @@ def peep_hole_call_function_ex_to_call_f
# exception.
expr = func_ir._definitions[vararg_name][0]
if isinstance(expr, ir.Expr) and expr.op == "list_to_tuple":
- raise UnsupportedError(errmsg)
+ raise UnsupportedBytecodeError(errmsg)
new_body.append(stmt)
# Replace the block body if we changed the IR
@@ -1197,7 +1201,7 @@ def peep_hole_fuse_dict_add_updates(func
else:
# If we cannot remove _update_from_bytecode
# Then raise an error for the user.
- raise UnsupportedError(errmsg)
+ raise UnsupportedBytecodeError(errmsg)
# Check if we need to drop any maps from being tracked.
# Skip the setitem/_update_from_bytecode getattr that
@@ -1385,7 +1389,7 @@ class Interpreter(object):
max(inst_blocks.body))
self.last_active_offset = last_active_offset
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
self.active_exception_entries = tuple(
[entry for entry in self.bytecode.exception_entries
if entry.start < self.last_active_offset])
@@ -1401,7 +1405,7 @@ class Interpreter(object):
# Interpret loop
for inst, kws in self._iter_inst():
self._dispatch(inst, kws)
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
# Insert end of try markers
self._end_try_blocks()
elif PYVERSION in ((3, 9), (3, 10)):
@@ -1418,12 +1422,12 @@ class Interpreter(object):
# post process the IR to rewrite opcodes/byte sequences that are too
# involved to risk handling as part of direct interpretation
peepholes = []
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
peepholes.append(peep_hole_split_at_pop_block)
- if PYVERSION in ((3, 9), (3, 10), (3, 11), (3, 12)):
+ if PYVERSION in ((3, 9), (3, 10), (3, 11), (3, 12), (3, 13)):
peepholes.append(peep_hole_list_to_tuple)
peepholes.append(peep_hole_delete_with_exit)
- if PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ if PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
# peep_hole_call_function_ex_to_call_function_kw
# depends on peep_hole_list_to_tuple converting
# any large number of arguments from a list to a
@@ -1456,7 +1460,7 @@ class Interpreter(object):
See also: _insert_try_block_end
"""
- assert PYVERSION in ((3, 11), (3, 12))
+ assert PYVERSION in ((3, 11), (3, 12), (3, 13))
graph = self.cfa.graph
for offset, block in self.blocks.items():
# Get current blockstack
@@ -1507,7 +1511,7 @@ class Interpreter(object):
first = uservar[0]
loc = self.current_scope.get(first).loc
msg = "Exception object cannot be stored into variable ({})."
- raise errors.UnsupportedError(msg.format(first), loc=loc)
+ raise errors.UnsupportedBytecodeError(msg.format(first), loc=loc)
def init_first_block(self):
# Define variables receiving the function arguments
@@ -1564,7 +1568,7 @@ class Interpreter(object):
self.dfainfo = self.dfa.infos[self.current_block_offset]
self.assigner = Assigner()
# Check out-of-scope syntactic-block
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
# This is recreating pre-3.11 code structure
while self.syntax_blocks:
if offset >= self.syntax_blocks[-1].exit:
@@ -1735,7 +1739,7 @@ class Interpreter(object):
val = self.get(varname)
except ir.NotDefinedError:
# Hack to make sure exception variables are defined
- assert PYVERSION in ((3, 11), (3, 12)), \
+ assert PYVERSION in ((3, 11), (3, 12), (3, 13)), \
"unexpected missing definition"
val = ir.Const(value=None, loc=self.loc)
stmt = ir.Assign(value=val, target=target,
@@ -1795,7 +1799,7 @@ class Interpreter(object):
if self._DEBUG_PRINT:
print(inst)
assert self.current_block is not None
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
if self.syntax_blocks:
top = self.syntax_blocks[-1]
if isinstance(top, ir.With) :
@@ -1825,6 +1829,9 @@ class Interpreter(object):
if not config.FULL_TRACEBACKS:
raise err from None
else:
+ m = f"handling op: {inst} | offset: {inst.offset}"
+ err.add_context(m)
+ err.add_context(self.bytecode.dump())
raise err
# --- Scope operations ---
@@ -1921,6 +1928,10 @@ class Interpreter(object):
loc=self.loc)
self.store(expr, st)
+ def op_FORMAT_SIMPLE(self, inst, value, res, strvar):
+ # Same as FORMAT_VALUE
+ return self.op_FORMAT_VALUE(inst, value, res, strvar)
+
def op_FORMAT_VALUE(self, inst, value, res, strvar):
"""
FORMAT_VALUE(flags): flags argument specifies format spec which is not
@@ -1971,7 +1982,7 @@ class Interpreter(object):
(), loc=self.loc)
self.store(value=sliceinst, name=res)
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
def op_BINARY_SLICE(self, inst, start, end, container, res, slicevar,
temp_res):
start = self.get(start)
@@ -1990,7 +2001,7 @@ class Interpreter(object):
else:
raise NotImplementedError(PYVERSION)
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
def op_STORE_SLICE(self, inst, start, end, container, value, res,
slicevar):
start = self.get(start)
@@ -2218,11 +2229,58 @@ class Interpreter(object):
stmt = ir.DelItem(base, self.get(indexvar), loc=self.loc)
self.current_block.append(stmt)
- def op_LOAD_FAST(self, inst, res):
+ def _op_LOAD_FAST(self, inst, res):
srcname = self.code_locals[inst.arg]
self.store(value=self.get(srcname), name=res)
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 13), ):
+ def op_LOAD_FAST(self, inst, res, as_load_deref=False):
+ if as_load_deref:
+ self.op_LOAD_DEREF(inst, res)
+ else:
+ self._op_LOAD_FAST(inst, res)
+
+ else:
+ op_LOAD_FAST = _op_LOAD_FAST
+
+ if PYVERSION in ((3, 13),):
+ def op_LOAD_FAST_LOAD_FAST(self, inst, res1, res2):
+ oparg = inst.arg
+ oparg1 = oparg >> 4
+ oparg2 = oparg & 15
+ src1 = self.get(self.code_locals[oparg1])
+ src2 = self.get(self.code_locals[oparg2])
+ self.store(value=src1, name=res1)
+ self.store(value=src2, name=res2)
+
+ def op_STORE_FAST_LOAD_FAST(self, inst, store_value, load_res):
+ oparg = inst.arg
+ oparg1 = oparg >> 4
+ oparg2 = oparg & 15
+
+ dstname = self.code_locals[oparg1]
+ dst_value = self.get(store_value)
+ self.store(value=dst_value, name=dstname)
+
+ src_value = self.get(self.code_locals[oparg2])
+ self.store(value=src_value, name=load_res)
+
+ def op_STORE_FAST_STORE_FAST(self, inst, value1, value2):
+ oparg = inst.arg
+ oparg1 = oparg >> 4
+ oparg2 = oparg & 15
+
+ dstname = self.code_locals[oparg1]
+ self.store(value=self.get(value1), name=dstname)
+ dstname = self.code_locals[oparg2]
+ self.store(value=self.get(value2), name=dstname)
+
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
+ if PYVERSION in ((3, 12), (3, 13)):
op_LOAD_FAST_CHECK = op_LOAD_FAST
def op_LOAD_FAST_AND_CLEAR(self, inst, res):
@@ -2269,7 +2327,7 @@ class Interpreter(object):
def op_LOAD_ATTR(self, inst, item, res):
item = self.get(item)
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
attr = self.code_names[inst.arg >> 1]
elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
attr = self.code_names[inst.arg]
@@ -2300,7 +2358,7 @@ class Interpreter(object):
const = ir.Const(value, loc=self.loc)
self.store(const, res)
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
def op_LOAD_GLOBAL(self, inst, idx, res):
name = self.code_names[idx]
value = self.get_global_value(name)
@@ -2318,11 +2376,15 @@ class Interpreter(object):
def op_COPY_FREE_VARS(self, inst):
pass
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
def op_LOAD_DEREF(self, inst, res):
name = self.func_id.func.__code__._varname_from_oparg(inst.arg)
if name in self.code_cellvars:
- gl = self.get(name)
+ try:
+ gl = self.get(name)
+ except NotDefinedError:
+ msg = "Unsupported use of cell variable encountered"
+ raise NotImplementedError(msg)
elif name in self.code_freevars:
idx = self.code_freevars.index(name)
value = self.get_closure_value(idx)
@@ -2343,11 +2405,11 @@ class Interpreter(object):
else:
raise NotImplementedError(PYVERSION)
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
def op_MAKE_CELL(self, inst):
pass # ignored bytecode
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
def op_STORE_DEREF(self, inst, value):
name = self.func_id.func.__code__._varname_from_oparg(inst.arg)
value = self.get(value)
@@ -2387,7 +2449,7 @@ class Interpreter(object):
def op_BEFORE_WITH(self, inst, contextmanager, exitfn, end):
assert self.blocks[inst.offset] is self.current_block
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
# Python 3.12 hack for handling nested with blocks
if end > self.last_active_offset:
# Use exception entries to figure out end of syntax block
@@ -2437,6 +2499,7 @@ class Interpreter(object):
func = self.get(func)
args = [self.get(x) for x in args]
if kw_names is not None:
+ assert PYVERSION < (3, 13)
names = self.code_consts[kw_names]
kwargs = list(zip(names, args[-len(names):]))
args = args[:-len(names)]
@@ -2445,6 +2508,19 @@ class Interpreter(object):
expr = ir.Expr.call(func, args, kwargs, loc=self.loc)
self.store(expr, res)
+ if PYVERSION in ((3, 13),):
+ def op_CALL_KW(self, inst, func, args, kw_names, res):
+ func = self.get(func)
+ args = [self.get(x) for x in args]
+ consti = int(kw_names.rsplit('.', 2)[-1])
+ names = self.code_consts[consti]
+ kwargs = list(zip(names, args[-len(names):]))
+ args = args[:-len(names)]
+ expr = ir.Expr.call(func, args, kwargs, loc=self.loc)
+ self.store(expr, res)
+ else:
+ assert PYVERSION < (3, 13)
+
def op_CALL_FUNCTION(self, inst, func, args, res):
func = self.get(func)
args = [self.get(x) for x in args]
@@ -2878,6 +2954,8 @@ class Interpreter(object):
jmp = ir.Jump(inst.get_jump_target(), loc=self.loc)
self.current_block.append(jmp)
+ op_JUMP_BACKWARD_NO_INTERRUPT = op_JUMP_BACKWARD
+
def op_POP_BLOCK(self, inst, kind=None):
if kind is None:
self.syntax_blocks.pop()
@@ -2892,7 +2970,7 @@ class Interpreter(object):
ret = ir.Return(self.get(castval), loc=self.loc)
self.current_block.append(ret)
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
def op_RETURN_CONST(self, inst, retval, castval):
value = self.code_consts[inst.arg]
const = ir.Const(value, loc=self.loc)
@@ -2905,8 +2983,20 @@ class Interpreter(object):
else:
raise NotImplementedError(PYVERSION)
+ if PYVERSION in ((3, 13),):
+ def op_TO_BOOL(self, inst, val, res):
+ self.store(self.get(val), res) # TODO: just a lazy hack
+
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ pass
+ else:
+ raise NotImplementedError(PYVERSION)
+
def op_COMPARE_OP(self, inst, lhs, rhs, res):
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 13),):
+ op = dis.cmp_op[inst.arg >> 5]
+ # TODO: fifth lowest bit now indicates a forced version to bool.
+ elif PYVERSION in ((3, 12),):
op = dis.cmp_op[inst.arg >> 4]
elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
op = dis.cmp_op[inst.arg]
@@ -3024,7 +3114,7 @@ class Interpreter(object):
def op_POP_JUMP_FORWARD_IF_NOT_NONE(self, inst, pred):
self._jump_if_none(inst, pred, False)
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
def op_POP_JUMP_IF_NONE(self, inst, pred):
self._jump_if_none(inst, pred, True)
@@ -3152,7 +3242,7 @@ class Interpreter(object):
"Probably caused by complex control-flow constructs; "
"e.g. try-except"
)
- raise errors.UnsupportedError(msg, loc=self.loc)
+ raise errors.UnsupportedBytecodeError(msg, loc=self.loc)
fcode = assume_code_const.value
if name:
name = self.get(name)
@@ -3166,14 +3256,14 @@ class Interpreter(object):
self.op_MAKE_FUNCTION(inst, name, code, closure, annotations,
kwdefaults, defaults, res)
- if PYVERSION in ((3, 11), (3, 12)):
+ if PYVERSION in ((3, 11), (3, 12), (3, 13)):
def op_LOAD_CLOSURE(self, inst, res):
name = self.func_id.func.__code__._varname_from_oparg(inst.arg)
if name in self.code_cellvars:
try:
gl = self.get(name)
except NotDefinedError:
- msg = "Unsupported use of op_LOAD_CLOSURE encountered"
+ msg = "Unsupported use of cell variable encountered"
raise NotImplementedError(msg)
elif name in self.code_freevars:
idx = self.code_freevars.index(name)
@@ -3191,7 +3281,7 @@ class Interpreter(object):
try:
gl = self.get(name)
except NotDefinedError:
- msg = "Unsupported use of op_LOAD_CLOSURE encountered"
+ msg = "Unsupported use of cell variable encountered"
raise NotImplementedError(msg)
else:
idx = inst.arg - n_cellvars
@@ -3228,7 +3318,7 @@ class Interpreter(object):
"op_LIST_EXTEND at the start of a block.\n\nThis could be "
"due to the use of a branch in a tuple unpacking statement.")
if not self.current_block.body:
- raise errors.UnsupportedError(msg)
+ raise errors.UnsupportedBytecodeError(msg)
# is last emitted statement a build_tuple?
stmt = self.current_block.body[-1]
@@ -3258,7 +3348,7 @@ class Interpreter(object):
ok = False
break
if ok and build_empty_list is None:
- raise errors.UnsupportedError(msg)
+ raise errors.UnsupportedBytecodeError(msg)
if ok:
stmts = self.current_block.body
build_tuple_asgn = self.current_block.body[-1]
@@ -3304,7 +3394,7 @@ class Interpreter(object):
def op_CALL_METHOD(self, *args, **kws):
self.op_CALL_FUNCTION(*args, **kws)
- if PYVERSION in ((3, 12), ):
+ if PYVERSION in ((3, 12), (3, 13)):
def op_CALL_INTRINSIC_1(self, inst, operand, **kwargs):
if operand == ci1op.INTRINSIC_STOPITERATION_ERROR:
stmt = ir.StaticRaise(INTRINSIC_STOPITERATION_ERROR, (),
@@ -3325,7 +3415,7 @@ class Interpreter(object):
raise NotImplementedError(PYVERSION)
-if PYVERSION in ((3, 12), ):
+if PYVERSION in ((3, 12), (3, 13)):
class INTRINSIC_STOPITERATION_ERROR(AssertionError):
pass
elif PYVERSION in ((3, 9), (3, 10), (3, 11)):
Index: numba-0.60.0/numba/cpython/unicode.py
===================================================================
--- numba-0.60.0.orig/numba/cpython/unicode.py
+++ numba-0.60.0/numba/cpython/unicode.py
@@ -349,7 +349,7 @@ def _set_code_point(a, i, ch):
"Unexpected unicode representation in _set_code_point")
-if PYVERSION in ((3, 12),):
+if PYVERSION in ((3, 12), (3, 13)):
@register_jitable
def _pick_kind(kind1, kind2):
if kind1 == PY_UNICODE_1BYTE_KIND:
@@ -393,7 +393,7 @@ def _pick_ascii(is_ascii1, is_ascii2):
return types.uint32(0)
-if PYVERSION in ((3, 12),):
+if PYVERSION in ((3, 12), (3, 13)):
@register_jitable
def _kind_to_byte_width(kind):
if kind == PY_UNICODE_1BYTE_KIND:
@@ -2047,7 +2047,7 @@ def _is_upper(is_lower, is_upper, is_tit
def impl(a):
l = len(a)
if l == 1:
- return is_upper(_get_code_point(a, 0))
+ return is_upper(_get_code_point(a, 0)) != 0
if l == 0:
return False
cased = False
Index: numba-0.60.0/numba/experimental/jitclass/base.py
===================================================================
--- numba-0.60.0.orig/numba/experimental/jitclass/base.py
+++ numba-0.60.0/numba/experimental/jitclass/base.py
@@ -282,6 +282,9 @@ def _drop_ignored_attrs(dct):
drop = set(['__weakref__',
'__module__',
'__dict__'])
+ if utils.PYVERSION == (3, 13):
+ # new in python 3.13
+ drop |= set(['__firstlineno__', '__static_attributes__'])
if '__annotations__' in dct:
drop.add('__annotations__')
@@ -300,7 +303,7 @@ def _drop_ignored_attrs(dct):
drop.add('__hash__')
for k in drop:
- del dct[k]
+ dct.pop(k)
class ClassBuilder(object):
Index: numba-0.60.0/numba/core/compiler.py
===================================================================
--- numba-0.60.0.orig/numba/core/compiler.py
+++ numba-0.60.0/numba/core/compiler.py
@@ -476,10 +476,7 @@ class CompilerBase(object):
res = e.result
break
except Exception as e:
- if (utils.use_new_style_errors() and not
- isinstance(e, errors.NumbaError)):
- raise e
-
+ utils.handle_new_style_errors(e)
self.state.status.fail_reason = e
if is_final_pipeline:
raise e
Index: numba-0.60.0/numba/core/compiler_machinery.py
===================================================================
--- numba-0.60.0.orig/numba/core/compiler_machinery.py
+++ numba-0.60.0/numba/core/compiler_machinery.py
@@ -304,7 +304,8 @@ class PassManager(object):
args=str(internal_state.args),
return_type=str(internal_state.return_type),
)
- with ev.trigger_event("numba:run_pass", data=ev_details):
+ errctx = errors.new_error_context(f"Pass {pss.name()}")
+ with ev.trigger_event("numba:run_pass", data=ev_details), errctx:
with SimpleTimer() as init_time:
mutated |= check(pss.run_initialization, internal_state)
with SimpleTimer() as pass_time:
@@ -359,9 +360,7 @@ class PassManager(object):
except _EarlyPipelineCompletion as e:
raise e
except Exception as e:
- if (utils.use_new_style_errors() and not
- isinstance(e, errors.NumbaError)):
- raise e
+ utils.handle_new_style_errors(e)
msg = "Failed in %s mode pipeline (step: %s)" % \
(self.pipeline_name, pass_desc)
patched_exception = self._patch_error(msg, e)
Index: numba-0.60.0/numba/core/errors.py
===================================================================
--- numba-0.60.0.orig/numba/core/errors.py
+++ numba-0.60.0/numba/core/errors.py
@@ -532,7 +532,6 @@ class WarningsFixer(object):
class NumbaError(Exception):
-
def __init__(self, msg, loc=None, highlighting=True):
self.msg = msg
self.loc = loc
@@ -578,7 +577,13 @@ class UnsupportedError(NumbaError):
"""
Numba does not have an implementation for this functionality.
"""
- pass
+
+
+class UnsupportedBytecodeError(Exception):
+ """Unsupported bytecode is non-recoverable
+ """
+ def __init__(self, msg, loc=None):
+ super().__init__(f"{msg}. Raised from {loc}")
class UnsupportedRewriteError(UnsupportedError):
Index: numba-0.60.0/numba/core/types/functions.py
===================================================================
--- numba-0.60.0.orig/numba/core/types/functions.py
+++ numba-0.60.0/numba/core/types/functions.py
@@ -307,12 +307,9 @@ class BaseFunction(Callable):
for k, v in kws.items()}
sig = temp.apply(nolitargs, nolitkws)
except Exception as e:
- if (utils.use_new_style_errors() and not
- isinstance(e, errors.NumbaError)):
- raise e
- else:
- sig = None
- failures.add_error(temp, False, e, uselit)
+ utils.handle_new_style_errors(e)
+ sig = None
+ failures.add_error(temp, False, e, uselit)
else:
if sig is not None:
self._impl_keys[sig.args] = temp.get_impl_key(sig)
Index: numba-0.60.0/numba/core/utils.py
===================================================================
--- numba-0.60.0.orig/numba/core/utils.py
+++ numba-0.60.0/numba/core/utils.py
@@ -230,6 +230,17 @@ def use_old_style_errors():
return res
+def handle_new_style_errors(e):
+ """Handle new_style error by raising the exception immediately if they are
+ non-recoverable.
+ """
+ from numba.core import errors
+
+ if use_new_style_errors():
+ if not isinstance(e, errors.NumbaError):
+ raise e
+
+
class ThreadLocalStack:
"""A TLS stack container.
Index: numba-0.60.0/numba/stencils/stencil.py
===================================================================
--- numba-0.60.0.orig/numba/stencils/stencil.py
+++ numba-0.60.0/numba/stencils/stencil.py
@@ -402,8 +402,9 @@ class StencilFunc(object):
sig = signature(real_ret, *argtys_extra)
dummy_text = ("def __numba_dummy_stencil({}{}):\n pass\n".format(
",".join(self.kernel_ir.arg_names), sig_extra))
- exec(dummy_text) in globals(), locals()
- dummy_func = eval("__numba_dummy_stencil")
+ 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)
@@ -659,8 +660,10 @@ class StencilFunc(object):
print(func_text)
# Force the new stencil function into existence.
- exec(func_text) in globals(), locals()
- stencil_func = eval(stencil_func_name)
+ 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
Index: numba-0.60.0/numba/tests/test_debug.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_debug.py
+++ numba-0.60.0/numba/tests/test_debug.py
@@ -73,7 +73,7 @@ class DebugTestBase(TestCase):
self.assert_fails(check_meth, out)
def _check_dump_bytecode(self, out):
- if utils.PYVERSION in ((3, 11), (3, 12)):
+ if utils.PYVERSION in ((3, 11), (3, 12), (3, 13)):
self.assertIn('BINARY_OP', out)
elif utils.PYVERSION in ((3, 9), (3, 10)):
self.assertIn('BINARY_ADD', out)
Index: numba-0.60.0/numba/tests/test_ir_inlining.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_ir_inlining.py
+++ numba-0.60.0/numba/tests/test_ir_inlining.py
@@ -444,7 +444,7 @@ class TestFunctionInlining(MemoryLeakMix
return bar(z + 2)
# block count changes with Python version due to bytecode differences.
- if utils.PYVERSION in ((3, 12), ):
+ if utils.PYVERSION in ((3, 12), (3, 13)):
bc = 39
elif utils.PYVERSION in ((3, 10), (3, 11)):
bc = 35
Index: numba-0.60.0/numba/tests/test_closure.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_closure.py
+++ numba-0.60.0/numba/tests/test_closure.py
@@ -400,13 +400,13 @@ class TestInlinedClosure(TestCase):
with self.assertRaises(NotImplementedError) as raises:
cfunc = jit(nopython=True)(outer3)
cfunc(var)
- msg = "Unsupported use of op_LOAD_CLOSURE encountered"
+ msg = "Unsupported use of cell variable encountered"
self.assertIn(msg, str(raises.exception))
with self.assertRaises(NotImplementedError) as raises:
cfunc = jit(nopython=True)(outer4)
cfunc(var)
- msg = "Unsupported use of op_LOAD_CLOSURE encountered"
+ msg = "Unsupported use of cell variable encountered"
self.assertIn(msg, str(raises.exception))
with self.assertRaises(TypingError) as raises:
Index: numba-0.60.0/numba/core/inline_closurecall.py
===================================================================
--- numba-0.60.0.orig/numba/core/inline_closurecall.py
+++ numba-0.60.0/numba/core/inline_closurecall.py
@@ -95,7 +95,7 @@ class InlineClosureCallPass(object):
modified = False
work_list = list(self.func_ir.blocks.items())
debug_print = _make_debug_print("InlineClosureCallPass")
- debug_print("START")
+ debug_print(f"START {self.func_ir.func_id.func_qualname}")
while work_list:
_label, block = work_list.pop()
for i, instr in enumerate(block.body):
Index: numba-0.60.0/numba/pycc/modulemixin.c
===================================================================
--- numba-0.60.0.orig/numba/pycc/modulemixin.c
+++ numba-0.60.0/numba/pycc/modulemixin.c
@@ -23,6 +23,12 @@
#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;
Index: numba-0.60.0/numba/tests/test_operators.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_operators.py
+++ numba-0.60.0/numba/tests/test_operators.py
@@ -768,7 +768,7 @@ class TestOperators(TestCase):
# error message depends on Python version.
if utils.PYVERSION in ((3, 9),):
msg = "can't mod complex numbers"
- elif utils.PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ elif utils.PYVERSION in ((3, 10), (3, 11), (3, 12), (3, 13)):
msg = "unsupported operand type(s) for %"
else:
raise NotImplementedError(utils.PYVERSION)
Index: numba-0.60.0/numba/tests/test_parfors.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_parfors.py
+++ numba-0.60.0/numba/tests/test_parfors.py
@@ -3550,7 +3550,7 @@ class TestPrangeBase(TestParforsBase):
prange_names.append('prange')
prange_names = tuple(prange_names)
prange_idx = len(prange_names) - 1
- if utils.PYVERSION in ((3, 11), (3, 12)):
+ if utils.PYVERSION in ((3, 11), (3, 12), (3, 13)):
# this is the inverse of _fix_LOAD_GLOBAL_arg
prange_idx = 1 + (prange_idx << 1)
elif utils.PYVERSION in ((3, 9), (3, 10)):
Index: numba-0.60.0/numba/tests/support.py
===================================================================
--- numba-0.60.0.orig/numba/tests/support.py
+++ numba-0.60.0/numba/tests/support.py
@@ -128,6 +128,12 @@ def expected_failure_np2(fn):
else:
return fn
+def expected_failure_py313(fn):
+ if utils.PYVERSION == (3, 13):
+ return unittest.expectedFailure(fn)
+ else:
+ return fn
+
_msg = "SciPy needed for test"
skip_unless_scipy = unittest.skipIf(scipy is None, _msg)
Index: numba-0.60.0/numba/tests/test_np_functions.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_np_functions.py
+++ numba-0.60.0/numba/tests/test_np_functions.py
@@ -6192,8 +6192,9 @@ def foo():
tystr = ty.__name__
basestr = basefunc.__name__
funcstr = self.template % (tystr, basestr)
- eval(compile(funcstr, '<string>', 'exec'))
- return locals()['foo']
+ dct = {}
+ exec(compile(funcstr, '<string>', 'exec'), globals(), dct)
+ return dct['foo']
@unittest.skipIf(numpy_version >= (1, 24), "NumPy < 1.24 required")
def test_MachAr(self):
Index: numba-0.60.0/numba/tests/test_unicode.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_unicode.py
+++ numba-0.60.0/numba/tests/test_unicode.py
@@ -6,10 +6,12 @@ from numba import njit, typeof
from numba.core import types
import unittest
from numba.tests.support import (TestCase, no_pyobj_flags, MemoryLeakMixin)
-from numba.core.errors import TypingError, UnsupportedError
+from numba.core.errors import (TypingError, UnsupportedError,
+ UnsupportedBytecodeError)
from numba.cpython.unicode import _MAX_UNICODE
from numba.core.types.functions import _header_lead
from numba.extending import overload
+from numba.core.utils import PYVERSION
def isascii(s):
@@ -2697,10 +2699,17 @@ class TestUnicodeAuxillary(BaseTest):
self.assertEqual(got, expected)
# check error when format spec provided
- with self.assertRaises(UnsupportedError) as raises:
+ unsupported_errors = (UnsupportedError, UnsupportedBytecodeError)
+ with self.assertRaises(unsupported_errors) as raises:
njit(impl4)(["A", "B"])
- msg = "format spec in f-strings not supported yet"
- self.assertIn(msg, str(raises.exception))
+ if PYVERSION in ((3, 13),):
+ msg = "Use of unsupported opcode (FORMAT_WITH_SPEC)"
+ self.assertIn(msg, str(raises.exception))
+ elif PYVERSION in ((3, 10), (3, 11), (3, 12)):
+ msg = "format spec in f-strings not supported yet"
+ self.assertIn(msg, str(raises.exception))
+ else:
+ raise NotImplementedError(PYVERSION)
self.assertEqual(impl5(), njit(impl5)())
Index: numba-0.60.0/numba/core/ir.py
===================================================================
--- numba-0.60.0.orig/numba/core/ir.py
+++ numba-0.60.0/numba/core/ir.py
@@ -90,9 +90,12 @@ class Loc(object):
def get_lines(self):
if self.lines is None:
-
- self.lines = linecache.getlines(self._get_path())
-
+ path = self._get_path()
+ # Avoid reading from dynamic string. They are most likely
+ # overridden. Problem started with Python 3.13. "<string>" seems
+ # to be something from multiprocessing.
+ lns = [] if path == "<string>" else linecache.getlines(path)
+ self.lines = lns
return self.lines
def _get_path(self):
@@ -1496,7 +1499,7 @@ class FunctionIR(object):
self.block_entry_vars = {}
def derive(self, blocks, arg_count=None, arg_names=None,
- force_non_generator=False):
+ force_non_generator=False, loc=None):
"""
Derive a new function IR from this one, using the given blocks,
and possibly modifying the argument count and generator flag.
@@ -1507,7 +1510,7 @@ class FunctionIR(object):
new_ir = copy.copy(self)
new_ir.blocks = blocks
- new_ir.loc = firstblock.loc
+ new_ir.loc = firstblock.loc if loc is None else loc
if force_non_generator:
new_ir.is_generator = False
if arg_count is not None:
Index: numba-0.60.0/numba/core/transforms.py
===================================================================
--- numba-0.60.0.orig/numba/core/transforms.py
+++ numba-0.60.0/numba/core/transforms.py
@@ -191,12 +191,20 @@ def _loop_lift_modify_blocks(func_ir, lo
loopblocks = dict((k, blocks[k].copy()) for k in loopblockkeys)
# Modify the loop blocks
_loop_lift_prepare_loop_func(loopinfo, loopblocks)
-
+ # Since Python 3.13, [END_FOR, POP_TOP] sequence becomes the start of the
+ # block causing the block to have line number of the start of previous loop.
+ # Fix this using the loc of the first getiter.
+ getiter_exprs = []
+ for blk in loopblocks.values():
+ getiter_exprs.extend(blk.find_exprs(op="getiter"))
+ first_getiter = min(getiter_exprs, key=lambda x: x.loc.line)
+ loop_loc = first_getiter.loc
# Create a new IR for the lifted loop
lifted_ir = func_ir.derive(blocks=loopblocks,
arg_names=tuple(loopinfo.inputs),
arg_count=len(loopinfo.inputs),
- force_non_generator=True)
+ force_non_generator=True,
+ loc=loop_loc)
liftedloop = LiftedLoop(lifted_ir,
typingctx, targetctx, flags, locals)
Index: numba-0.60.0/numba/tests/test_exceptions.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_exceptions.py
+++ numba-0.60.0/numba/tests/test_exceptions.py
@@ -6,6 +6,7 @@ from numba import jit, njit
from numba.core import types, errors, utils
from numba.tests.support import (TestCase, expected_failure_py311,
expected_failure_py312,
+ expected_failure_py313,
)
import unittest
@@ -440,6 +441,7 @@ class TestRaising(TestCase):
@expected_failure_py311
@expected_failure_py312
+ @expected_failure_py313
def test_dynamic_raise(self):
@njit
Index: numba-0.60.0/numba/tests/test_try_except.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_try_except.py
+++ numba-0.60.0/numba/tests/test_try_except.py
@@ -8,12 +8,13 @@ from numba import njit, typed, objmode,
from numba.core.utils import PYVERSION
from numba.core import ir_utils, ir
from numba.core.errors import (
- UnsupportedError, CompilerError, NumbaPerformanceWarning, TypingError,
+ CompilerError, NumbaPerformanceWarning, TypingError,
+ UnsupportedBytecodeError,
)
from numba.tests.support import (
TestCase, unittest, captured_stdout, MemoryLeakMixin,
skip_parfors_unsupported, skip_unless_scipy, expected_failure_py311,
- expected_failure_py312
+ expected_failure_py312, expected_failure_py313,
)
@@ -372,7 +373,7 @@ class TestTryBareExcept(TestCase):
except: # noqa: E722
raise
- with self.assertRaises(UnsupportedError) as raises:
+ with self.assertRaises(UnsupportedBytecodeError) as raises:
udt()
self.assertIn(
"The re-raising of an exception is not yet supported.",
@@ -459,7 +460,7 @@ class TestTryExceptCaught(TestCase):
return r
return r
- with self.assertRaises(UnsupportedError) as raises:
+ with self.assertRaises(UnsupportedBytecodeError) as raises:
udt(True)
self.assertIn(
"Exception object cannot be stored into variable (e)",
@@ -474,7 +475,7 @@ class TestTryExceptCaught(TestCase):
except Exception:
raise
- with self.assertRaises(UnsupportedError) as raises:
+ with self.assertRaises(UnsupportedBytecodeError) as raises:
udt()
self.assertIn(
"The re-raising of an exception is not yet supported.",
@@ -492,7 +493,7 @@ class TestTryExceptCaught(TestCase):
except Exception:
raise
- with self.assertRaises(UnsupportedError) as raises:
+ with self.assertRaises(UnsupportedBytecodeError) as raises:
udt()
self.assertIn(
"The re-raising of an exception is not yet supported.",
@@ -692,6 +693,7 @@ class TestTryExceptOtherControlFlow(Test
@expected_failure_py311
@expected_failure_py312
+ @expected_failure_py313
def test_objmode(self):
@njit
def udt():
@@ -712,6 +714,7 @@ class TestTryExceptOtherControlFlow(Test
@expected_failure_py311
@expected_failure_py312
+ @expected_failure_py313
def test_objmode_output_type(self):
def bar(x):
return np.asarray(list(reversed(x.tolist())))
Index: numba-0.60.0/numba/tests/test_withlifting.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_withlifting.py
+++ numba-0.60.0/numba/tests/test_withlifting.py
@@ -16,7 +16,8 @@ from numba.tests.support import (MemoryL
skip_unless_scipy, linux_only,
strace_supported, strace,
expected_failure_py311,
- expected_failure_py312)
+ expected_failure_py312,
+ expected_failure_py313)
from numba.core.utils import PYVERSION
from numba.experimental import jitclass
import unittest
@@ -280,6 +281,7 @@ class TestLiftCall(BaseTestWithLifting):
@expected_failure_py311
@expected_failure_py312
+ @expected_failure_py313
def test_liftcall5(self):
self.check_extracted_with(liftcall5, expect_count=1,
expected_stdout="0\n1\n2\n3\n4\n5\nA\n")
@@ -719,6 +721,7 @@ class TestLiftObj(MemoryLeak, TestCase):
@expected_failure_py311
@expected_failure_py312
+ @expected_failure_py313
def test_case19_recursion(self):
def foo(x):
with objmode_context():
@@ -1169,7 +1172,7 @@ class TestBogusContext(BaseTestWithLifti
with open('') as f:
pass
- with self.assertRaises(errors.UnsupportedError) as raises:
+ with self.assertRaises(errors.UnsupportedBytecodeError) as raises:
foo()
excstr = str(raises.exception)
Index: numba-0.60.0/numba/tests/test_sys_monitoring.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_sys_monitoring.py
+++ numba-0.60.0/numba/tests/test_sys_monitoring.py
@@ -4,7 +4,7 @@ import sys
import threading
import unittest
from unittest.mock import Mock, call
-from numba.tests.support import TestCase, skip_unless_py312
+from numba.tests.support import TestCase
from numba import jit, objmode
from numba.core.utils import PYVERSION
from numba.core.serialize import _numba_unpickle
@@ -21,7 +21,7 @@ def generate_usecase():
return foo, call_foo
-if PYVERSION == (3, 12):
+if PYVERSION in ((3, 12), (3, 13)):
PY_START = sys.monitoring.events.PY_START
PY_RETURN = sys.monitoring.events.PY_RETURN
RAISE = sys.monitoring.events.RAISE
@@ -36,7 +36,7 @@ TOOL2MONITORTYPE = {0 : "Debugger",
5 : "Optimizer"}
-@skip_unless_py312
+@unittest.skipUnless(PYVERSION >= (3, 12), "needs Python 3.12+")
class TestMonitoring(TestCase):
# Tests the interaction of the Numba dispatcher with `sys.monitoring`.
#
@@ -724,7 +724,7 @@ class TestMonitoring(TestCase):
self.assertFalse(q2.qsize())
-@skip_unless_py312
+@unittest.skipUnless(PYVERSION >= (3, 12), "needs Python 3.12+")
class TestMonitoringSelfTest(TestCase):
def test_skipping_of_tests_if_monitoring_in_use(self):
Index: numba-0.60.0/numba/_random.c
===================================================================
--- numba-0.60.0.orig/numba/_random.c
+++ numba-0.60.0/numba/_random.c
@@ -195,7 +195,7 @@ rnd_implicit_init(rnd_state_t *state)
Py_buffer buf;
PyGILState_STATE gilstate = PyGILState_Ensure();
- module = PyImport_ImportModuleNoBlock("os");
+ module = PyImport_ImportModule("os");
if (module == NULL)
goto error;
/* Read as many bytes as necessary to get the full entropy
Index: numba-0.60.0/numba/core/pythonapi.py
===================================================================
--- numba-0.60.0.orig/numba/core/pythonapi.py
+++ numba-0.60.0/numba/core/pythonapi.py
@@ -919,9 +919,9 @@ class PythonAPI(object):
# Other APIs (organize them better!)
#
- def import_module_noblock(self, modname):
+ def import_module(self, modname):
fnty = ir.FunctionType(self.pyobj, [self.cstring])
- fn = self._get_function(fnty, name="PyImport_ImportModuleNoBlock")
+ fn = self._get_function(fnty, name="PyImport_ImportModule")
return self.builder.call(fn, [modname])
def call_function_objargs(self, callee, objargs):
Index: numba-0.60.0/numba/experimental/function_type.py
===================================================================
--- numba-0.60.0.orig/numba/experimental/function_type.py
+++ numba-0.60.0/numba/experimental/function_type.py
@@ -181,7 +181,7 @@ def lower_get_wrapper_address(context, b
# caller.
modname = context.insert_const_string(builder.module, __name__)
- numba_mod = pyapi.import_module_noblock(modname)
+ numba_mod = pyapi.import_module(modname)
numba_func = pyapi.object_getattr_string(
numba_mod, '_get_wrapper_address')
pyapi.decref(numba_mod)
@@ -263,3 +263,4 @@ def lower_cast_dispatcher_to_function_ty
llty = context.get_value_type(types.voidptr)
sfunc.pyaddr = builder.ptrtoint(val, llty)
return sfunc._getvalue()
+
Index: numba-0.60.0/numba/typed/typeddict.py
===================================================================
--- numba-0.60.0.orig/numba/typed/typeddict.py
+++ numba-0.60.0/numba/typed/typeddict.py
@@ -266,7 +266,7 @@ def box_dicttype(typ, val, c):
modname = c.context.insert_const_string(
c.builder.module, 'numba.typed.typeddict',
)
- typeddict_mod = c.pyapi.import_module_noblock(modname)
+ typeddict_mod = c.pyapi.import_module(modname)
fmp_fn = c.pyapi.object_getattr_string(typeddict_mod, '_from_meminfo_ptr')
dicttype_obj = c.pyapi.unserialize(c.pyapi.serialize_object(typ))
Index: numba-0.60.0/numba/typed/typedlist.py
===================================================================
--- numba-0.60.0.orig/numba/typed/typedlist.py
+++ numba-0.60.0/numba/typed/typedlist.py
@@ -471,7 +471,7 @@ def box_lsttype(typ, val, c):
modname = c.context.insert_const_string(
c.builder.module, 'numba.typed.typedlist',
)
- typedlist_mod = c.pyapi.import_module_noblock(modname)
+ typedlist_mod = c.pyapi.import_module(modname)
fmp_fn = c.pyapi.object_getattr_string(typedlist_mod, '_from_meminfo_ptr')
lsttype_obj = c.pyapi.unserialize(c.pyapi.serialize_object(typ))
Index: numba-0.60.0/numba/tests/test_interpreter.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_interpreter.py
+++ numba-0.60.0/numba/tests/test_interpreter.py
@@ -5,7 +5,7 @@ import unittest
from numba import jit, njit, objmode, typeof, literally
from numba.extending import overload
from numba.core import types
-from numba.core.errors import UnsupportedError
+from numba.core.errors import UnsupportedBytecodeError
from numba.tests.support import (
TestCase,
MemoryLeakMixin,
@@ -388,7 +388,7 @@ class TestCallFunctionExPeepHole(MemoryL
arg41=1,
)
- with self.assertRaises(UnsupportedError) as raises:
+ with self.assertRaises(UnsupportedBytecodeError) as raises:
njit()(inline_func)(False)
self.assertIn(
'You can resolve this issue by moving the control flow out',
@@ -498,7 +498,7 @@ class TestCallFunctionExPeepHole(MemoryL
1,
)
- with self.assertRaises(UnsupportedError) as raises:
+ with self.assertRaises(UnsupportedBytecodeError) as raises:
njit()(inline_func)(False)
self.assertIn(
'You can resolve this issue by moving the control flow out',
@@ -585,7 +585,7 @@ class TestCallFunctionExPeepHole(MemoryL
arg15=1 if flag else 2,
)
- with self.assertRaises(UnsupportedError) as raises:
+ with self.assertRaises(UnsupportedBytecodeError) as raises:
njit()(inline_func)(False)
self.assertIn(
'You can resolve this issue by moving the control flow out',
@@ -973,7 +973,7 @@ class TestLargeConstDict(TestCase, Memor
}
return d["S"]
- with self.assertRaises(UnsupportedError) as raises:
+ with self.assertRaises(UnsupportedBytecodeError) as raises:
njit()(inline_func)("a_string", False)
self.assertIn(
'You can resolve this issue by moving the control flow out',
Index: numba-0.60.0/numba/tests/test_tuples.py
===================================================================
--- numba-0.60.0.orig/numba/tests/test_tuples.py
+++ numba-0.60.0/numba/tests/test_tuples.py
@@ -731,7 +731,7 @@ class TestTupleBuild(TestCase):
b = (3,2, 4)
return (*(b if a[0] else (5, 6)),)
- with self.assertRaises(errors.UnsupportedError) as raises:
+ with self.assertRaises(errors.UnsupportedBytecodeError) as raises:
foo()
msg = "op_LIST_EXTEND at the start of a block"
self.assertIn(msg, str(raises.exception))
Index: numba-0.60.0/setup.py
===================================================================
--- numba-0.60.0.orig/setup.py
+++ numba-0.60.0/setup.py
@@ -20,7 +20,7 @@ except ImportError:
min_python_version = "3.9"
-max_python_version = "3.13" # exclusive
+max_python_version = "3.14" # exclusive
min_numpy_build_version = "2.0.0rc1"
min_numpy_run_version = "1.22"
max_numpy_run_version = "2.1"
Index: numba-0.60.0/numba/core/boxing.py
===================================================================
--- numba-0.60.0.orig/numba/core/boxing.py
+++ numba-0.60.0/numba/core/boxing.py
@@ -655,7 +655,7 @@ class _NumbaTypeHelper(object):
def __enter__(self):
c = self.c
numba_name = c.context.insert_const_string(c.builder.module, 'numba')
- numba_mod = c.pyapi.import_module_noblock(numba_name)
+ numba_mod = c.pyapi.import_module(numba_name)
typeof_fn = c.pyapi.object_getattr_string(numba_mod, 'typeof')
self.typeof_fn = typeof_fn
c.pyapi.decref(numba_mod)
@@ -1213,7 +1213,7 @@ def unbox_numpy_random_bitgenerator(typ,
# store the results.
# First find ctypes.cast, and ctypes.c_void_p
ctypes_name = c.context.insert_const_string(c.builder.module, 'ctypes')
- ctypes_module = c.pyapi.import_module_noblock(ctypes_name)
+ ctypes_module = c.pyapi.import_module(ctypes_name)
extra_refs.append(ctypes_module)
with cgutils.early_exit_if_null(c.builder, stack, ctypes_module):
handle_failure()
Index: numba-0.60.0/numba/pythoncapi_compat.h
===================================================================
--- /dev/null
+++ numba-0.60.0/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
Reference in New Issue Copy Permalink