numpy 2.5.4

Source: https://github.com/numpy/numpy
Tag scanned: v2.5.4
Compared with: v2.5.3 (0 signals introduced since)
Files: 1826 scanned, 416 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 4 warn · 134 info
Scan time: 92.7 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): the 115 most severe of 119 warn and critical signals (115 with a verdict); 115 demoted to info. The rest are unreviewed.
Disclude version: 4.1.0
Scanned (UTC): 2026-10-21 21:09

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

warn dynamic-execution numpy/testing/_private/utils.py:1640:9

`exec` called on a non-literal expression (ast pass, confidence 0.70)

        i += 1
        exec(code, globs, locs)
    elapsed = jiffies() - elapsed
    return 0.01 * elapsed

warn dynamic-execution numpy/tests/test_public_api.py:322:13

`eval` called on a non-literal expression (ast pass, confidence 0.70)

        try:
            eval(module_name)
        except AttributeError:
            module_names.append(module_name)

warn dynamic-attribute numpy/typing/__init__.py:211:16

reach-by-name through `globals` (ast pass, confidence 0.60)

    if name in __DIR_SET:
        return globals()[name]

    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

warn dynamic-execution tools/write_release.py:54:5

`os.system` called with a literal shell command (ast pass, confidence 0.70)

    # translate README.rst to md for posting on GitHub
    os.system(f"cp {notes} {target_rst}")
    subprocess.run(
        ["pandoc", "-s", "-o", str(target_md), str(target_rst), "--wrap=preserve"],

info ~~warn~~ → info by review dynamic-execution benchmarks/benchmarks/bench_indexing.py:29:9

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
        exec(code, ns)
        self.func = ns['run']
```
likely benign LLM, confidence 0.85 exec of generated benchmark code into a namespace, then retrieves a function.
Reasoning
exec on a code string in a benchmark setup builds a function from generated source; common in numpy benchmarks for generating test code, no sign of malicious intent.
info ~~critical~~ → info by review dynamic-import doc/source/conf.py:506:9

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
    try:
        __import__(name)
        extensions.append(name)
        break
```
likely benign LLM, confidence 0.80 __import__ of extension names inside a try loop in Sphinx config.
Reasoning
Sphinx conf.py tries importing extension names from a list in a try block; dynamic import of configured extensions is routine. Severity critical is overstated for this context.
info identifier-low-length doc/source/user/c-info.python-as-glue.rst:657:1

[embedded c] 24 of 51 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info identifier-low-length doc/source/user/c-info.python-as-glue.rst:798:1

[embedded python] 16 of 38 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info ~~warn~~ → info by review dynamic-attribute numpy/__init__.py:449:13

reach-by-name through `globals` (ast pass, confidence 0.60)
```
        try:
            globals()[ta] = getattr(_core, ta)
        except AttributeError:
            pass
```
likely benign LLM, confidence 0.80 Re-exports names from numpy._core into module globals.
Reasoning
Copying attributes from _core into the numpy namespace via globals() is a standard re-export pattern; the target names are fixed internal names.
info ~~critical~~ → info by review frame-introspection numpy/_build_utils/tempita/_tempita.py:128:26

`sys._getframe` — call-stack frame introspection — file also calls `sys.exit`/`exec`/`eval` (anti-analysis shape) (ast pass, confidence 0.85)
```
            try:
                caller = sys._getframe(stacklevel)
            except ValueError:
                pass
```
likely benign LLM, confidence 0.85 Tempita reads the caller frame to resolve template namespace.
Reasoning
sys._getframe is used by the tempita template engine to find the caller's namespace for templating; the exit/exec co-occurrence is a template-engine feature, not anti-analysis.
info ~~warn~~ → info by review dynamic-execution numpy/_build_utils/tempita/_tempita.py:320:25

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
            try:
                value = eval(code, self.default_namespace, ns)
            except SyntaxError as e:
                raise SyntaxError(f"invalid syntax in expression: {code}")
```
likely benign LLM, confidence 0.85 Template engine evaluating template expressions in a namespace.
Reasoning
Tempita evaluates template expressions by design; the template engine is a code generator used at build time, so eval is its intended function.
info ~~warn~~ → info by review dynamic-execution numpy/_build_utils/tempita/_tempita.py:335:13

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
        try:
            exec(code, self.default_namespace, ns)
        except Exception as e:
            if e.args:
```
likely benign LLM, confidence 0.85 Template engine executing template code blocks.
Reasoning
Tempita executes template statement blocks by design as part of its templating language.
info ~~warn~~ → info by review dynamic-execution numpy/_build_utils/tempita/_tempita.py:1098:21

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
            name = name[:3]
            value = eval(value)
        vars[name] = value
    if template_name == "-":
```
likely benign LLM, confidence 0.80 Tempita CLI evaluates a variable value passed as an argument.
Reasoning
Command-line variable parsing in tempita evals a user-supplied value, a documented feature of the build tool; not a hidden dropper.
info ~~critical~~ → info by review dynamic-import numpy/_core/function_base.py:537:19

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
    """
    new = getattr(__import__(place, globals(), {}, [obj]), obj)
    if isinstance(doc, str):
        if "${ARRAY_FUNCTION_LIKE}" in doc:
```
likely benign LLM, confidence 0.85 Imports a module by name to fetch a function for docstring substitution.
Reasoning
Docstring-decorator helper imports a module named by the developer-supplied place argument to attach array function docs; legitimate internal code.
info ~~warn~~ → info by review identifier-confusable-collision numpy/_core/include/numpy/libdivide/libdivide.h:219:14

two identifiers collapse to visual skeleton `x|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
static inline uint32_t libdivide_mullhi_u32(uint32_t x, uint32_t y) {
    uint64_t xl = x, yl = y;
    uint64_t rl = xl * yl;
    return (uint32_t)(rl >> 32);
```
likely benign LLM, confidence 0.90 Short variable names in a 32-bit multiply-high helper.
Reasoning
Variables xl/yl and x/y are ordinary short names; the skeleton collision reflects normal naming, not homoglyph attack in a mul-hi helper.
info ~~warn~~ → info by review identifier-confusable-collision numpy/_core/include/numpy/libdivide/libdivide.h:219:22

two identifiers collapse to visual skeleton `y|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
static inline uint32_t libdivide_mullhi_u32(uint32_t x, uint32_t y) {
    uint64_t xl = x, yl = y;
    uint64_t rl = xl * yl;
    return (uint32_t)(rl >> 32);
```
likely benign LLM, confidence 0.90 Parameter y in a 32-bit multiply-high helper.
Reasoning
Same function; x and y names with xl/yl are standard and the collision is a false positive from the skeleton heuristic.
info ~~warn~~ → info by review dynamic-attribute numpy/_core/numerictypes.py:550:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
for key in allTypes:
    globals()[key] = allTypes[key]
    __all__.append(key)
```
likely benign LLM, confidence 0.85 Exports scalar type aliases into module globals.
Reasoning
Populates module globals from a fixed table of type names, a common numpy pattern for exporting scalar types.
info identifier-low-length numpy/_core/src/_simd/checks/cpu_avx512_knm.c:1:1

20 of 48 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info ~~warn~~ → info by review identifier-confusable-collision numpy/_core/src/common/simd/avx2/reorder.h:87:12

two identifiers collapse to visual skeleton `ab|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    __m256 ab0 = _mm256_unpacklo_ps(a, b);
    __m256 ab1 = _mm256_unpackhi_ps(a, b);
    return npyv_combine_f32(ab0, ab1);
}
```
likely benign LLM, confidence 0.92 SIMD interleave helper using ab0 and ab1 vectors.
Reasoning
ab0/ab1 are standard SIMD lane variable names; the skeleton collision is a heuristic false positive.
info ~~warn~~ → info by review identifier-confusable-collision numpy/_core/src/common/simd/avx512/reorder.h:109:13

two identifiers collapse to visual skeleton `ab|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    __m512i ab0 = _mm512_unpacklo_epi8(a, b);
    __m512i ab1 = _mm512_unpackhi_epi8(a, b);
    #else
    __m512i ab0 = npyv__unpacklo_epi8(a, b);
```
likely benign LLM, confidence 0.92 AVX-512 reorder helper with ab0 and ab1 variables.
Reasoning
Same ab0/ab1 naming in an AVX-512 reorder helper; benign naming.
info ~~warn~~ → info by review identifier-confusable-collision numpy/_core/src/common/simd/sse/reorder.h:85:58

two identifiers collapse to visual skeleton `ab|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
// deinterleave two vectors
NPY_FINLINE npyv_u8x2 npyv_unzip_u8(npyv_u8 ab0, npyv_u8 ab1)
{
#ifdef NPY_HAVE_SSSE3
```
likely benign LLM, confidence 0.92 SSE unzip function with ab0 and ab1 parameters.
Reasoning
ab0/ab1 are parameter names for an unzip intrinsic wrapper; benign.
info ~~warn~~ → info by review identifier-confusable-collision numpy/_core/src/multiarray/multiarraymodule.c:2519:15

two identifiers collapse to visual skeleton `ao` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
{
    PyObject *a0;
    PyObject *out = NULL;
    PyArray_Descr *dtype = NULL;
```
likely benign LLM, confidence 0.90 C local variables a0 and out in multiarray module.
Reasoning
a0 and out are ordinary C locals; the skeleton match is a false positive from short names.
info ~~warn~~ → info by review identifier-confusable-collision numpy/_core/src/npysort/timsort.hpp:98:15

two identifiers collapse to visual skeleton `p|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    npy_intp sz;
    type vc, *pl, *pi, *pj, *pr;

    if (NPY_UNLIKELY(num - l == 1)) {
```
likely benign LLM, confidence 0.92 Timsort pointer locals pl, pi, pj, pr.
Reasoning
pl/pi/pj/pr are standard timsort pointer names; the collision is a heuristic artifact.
info ~~warn~~ → info by review identifier-confusable-collision numpy/_core/src/npysort/timsort_generic.cpp:133:11

two identifiers collapse to visual skeleton `p|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    npy_intp sz;
    char *pl, *pi, *pj, *pr;

    if (NPY_UNLIKELY(num - l == 1)) {
```
likely benign LLM, confidence 0.80 Local pointer variables in the numpy timsort implementation that collide under a confusable-character skeleton.
Reasoning
The flagged pair is ordinary local pointer names (pl, pi, pj, pr) in a C sorting routine. A visual-skeleton collision between short identifiers is a common false positive for token-pass confusable checks, and nothing in the snippet suggests deliberate disguise.
info ~~critical~~ → info by review format-string-write numpy/_core/src/umath/_rational_tests.c:353:23

printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)
```
    const char* ss;
    if (sscanf(*s,"%ld%n",&n,&offset)<=0) {
        return 0;
    }
```
dismissed LLM, confidence 0.90 sscanf parsing a long with %n to capture the consumed offset in numpy's rational test extension.
Reasoning
The %n in sscanf is a standard way to record how many characters were consumed, and it is paired with a fixed-format %ld input parse. This is a scanf output directive, not an attacker-controlled printf format string, so the write-to-memory concern does not apply.
info ~~critical~~ → info by review format-string-write numpy/_core/src/umath/_rational_tests.c:363:23

printf format directive `%n` writes to memory (in string literal) (token pass, confidence 0.90)
```
    ss++;
    if (sscanf(ss,"%ld%n",&d,&offset)<=0 || d<=0) {
        return 0;
    }
```
dismissed LLM, confidence 0.90 Second sscanf call using %n to track parse position in the rational test extension.
Reasoning
Same pattern as the other finding: a literal sscanf format with %ld%n storing the parse offset into a local integer. It is normal C parsing code in a test extension.

info unicode-homoglyph numpy/_core/strings.py:1776:55

identifier `κόσμε` contains homoglyph candidates: κ (03BA)→k (in string/comment) (raw pass, confidence 0.35)


    >>> b = np.array(['hello world', 'γεια σου κόσμε', '你好世界', '👋 🌍'],
    ...              dtype=np.dtypes.StringDType())
    >>> np.strings.slice(b, -2)

info unicode-mixed-script numpy/_core/strings.py:1776:55

identifier `κόσμε` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)


    >>> b = np.array(['hello world', 'γεια σου κόσμε', '你好世界', '👋 🌍'],
    ...              dtype=np.dtypes.StringDType())
    >>> np.strings.slice(b, -2)

info unicode-mixed-script numpy/_core/strings.py:1782:19

identifier `με` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

    >>> np.strings.slice(b, -2, None)
    array(['ld', 'με', '世界', ' 🌍'], dtype=StringDType())

    >>> np.strings.slice(b, [3, -10, 2, -3], [-1, -2, -1, 3])

info unicode-homoglyph numpy/_core/strings.py:1788:28

identifier `εμσόκ` contains homoglyph candidates: κ (03BA)→k (in string/comment) (raw pass, confidence 0.35)

    >>> np.strings.slice(b, None, None, -1)
    array(['dlrow olleh', 'εμσόκ υοσ αιεγ', '界世好你', '🌍 👋'],
          dtype=StringDType())

info unicode-mixed-script numpy/_core/strings.py:1788:28

identifier `εμσόκ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

    >>> np.strings.slice(b, None, None, -1)
    array(['dlrow olleh', 'εμσόκ υοσ αιεγ', '界世好你', '🌍 👋'],
          dtype=StringDType())

info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_arrayprint.py:343:22

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        assert_equal(eval(repr(a), vars(np)), a)
        assert_equal(eval(repr(a[0]), {'np': np}), a[0])
```
likely benign LLM, confidence 0.90 Test asserting that eval(repr(array)) reconstructs the original array.
Reasoning
This is a round-trip test checking that repr output evaluates back to an equal array. The eval input is the library's own repr output, and the namespace is restricted to numpy. This is expected test code.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_arrayprint.py:344:22

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        assert_equal(eval(repr(a), vars(np)), a)
        assert_equal(eval(repr(a[0]), {'np': np}), a[0])

    def test_edgeitems_kwarg(self):
```
likely benign LLM, confidence 0.90 Test asserting that eval(repr(a[0])) round-trips correctly.
Reasoning
Repeat of the repr round-trip test for a single array element, using a restricted namespace containing only np. It is legitimate test code for repr behavior.
info ~~warn~~ → info by review decoder-import-with-exec numpy/_core/tests/test_dtype.py:996:31

file imports decoder module(s) pickle and calls `exec`/`eval`/`compile` — multi-stage payload shape (ast pass, confidence 0.80)
```
                         "'aligned':True}")
        assert_equal(np.dtype(eval(str(dt))), dt)

        dt = np.dtype({'names': ['r', 'g', 'b'], 'formats': ['u1', 'u1', 'u1'],
```
likely benign LLM, confidence 0.90 Test evaluating str(dtype) to check dtype round-trip, in a file that also tests pickling.
Reasoning
The file imports pickle, and the eval here reconstructs a dtype from its own str() output in a test. The pickle/eval co-occurrence is a generic heuristic that matches numpy's test suite. No payload or decode chain is present.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_dtype.py:996:31

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
                         "'aligned':True}")
        assert_equal(np.dtype(eval(str(dt))), dt)

        dt = np.dtype({'names': ['r', 'g', 'b'], 'formats': ['u1', 'u1', 'u1'],
```
likely benign LLM, confidence 0.90 Eval of a dtype's string form in a numpy dtype round-trip test.
Reasoning
Same eval(str(dt)) round-trip test as the paired finding. It operates on numpy's own dtype string representation.
info ~~warn~~ → info by review decoder-import-with-exec numpy/_core/tests/test_multiarray.py:1704:28

file imports decoder module(s) pickle and calls `exec`/`eval`/`compile` — multi-stage payload shape (ast pass, confidence 0.80)
```
        assert_equal(xx[:].dtype, xx.dtype)
        assert_array_equal(eval(repr(xx), {"np": np, "array": np.array}), xx)

        b = io.BytesIO()
```
likely benign LLM, confidence 0.90 Test evaluating array repr with a restricted namespace and comparing equality.
Reasoning
This test evals the repr of a local array with a restricted namespace and then checks equality. The pickle import is part of numpy's serialization tests. No decoding or staged execution is shown.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_multiarray.py:1704:28

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        assert_equal(xx[:].dtype, xx.dtype)
        assert_array_equal(eval(repr(xx), {"np": np, "array": np.array}), xx)

        b = io.BytesIO()
```
likely benign LLM, confidence 0.90 Eval of an array repr in a numpy multiarray round-trip test.
Reasoning
Same eval(repr(xx)) round-trip test, using an explicit namespace dict with np and array. This is ordinary test code.
info ~~warn~~ → info by review payload-bytes-literal numpy/_core/tests/test_multiarray.py:5020:31

bytes literal contains 90 `\xNN` escapes (84% of content) — binary payload shape (ast pass, confidence 0.85)
```
        c_contiguous_dumped = b'\x80\x05\x95\x90\x00\x00\x00\x00\x00\x00\x00\x8c\x13numpy._core.numeric\x94\x8c\x0b_frombuffer\x94\x93\x94(\x96\x18\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x94\x8c\x05numpy\x94\x8c\x05dtype\x94\x93\x94\x8c\x02u
```
likely benign LLM, confidence 0.85 Fixture bytes containing a serialized C-contiguous numpy array pickle for compatibility testing.
Reasoning
The bytes literal is a protocol-5 pickle of a numpy array, used as a fixed fixture to check unpickling compatibility. It is test data inside a numpy test, not a hidden dropper. The escape density is expected for binary pickle data.
info ~~warn~~ → info by review payload-bytes-literal numpy/_core/tests/test_multiarray.py:5021:31

bytes literal contains 90 `\xNN` escapes (84% of content) — binary payload shape (ast pass, confidence 0.85)
```
        f_contiguous_dumped = b'\x80\x05\x95\x90\x00\x00\x00\x00\x00\x00\x00\x8c\x13numpy._core.numeric\x94\x8c\x0b_frombuffer\x94\x93\x94(\x96\x18\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x94\x8c\x05numpy\x94\x8c\x05dtype\x94\x93\x94\x8c\x02u
```
likely benign LLM, confidence 0.85 Fixture bytes holding a serialized F-contiguous numpy array pickle.
Reasoning
Another pickle fixture of a numpy array, this time F-contiguous, used in serialization tests. The byte pattern matches a standard numpy pickle with no executable payload chain.
info ~~warn~~ → info by review payload-bytes-literal numpy/_core/tests/test_multiarray.py:5022:40

bytes literal contains 94 `\xNN` escapes (82% of content) — binary payload shape (ast pass, confidence 0.85)
```
        transposed_contiguous_dumped = b'\x80\x05\x95\xa5\x00\x00\x00\x00\x00\x00\x00\x8c\x16numpy._core.multiarray\x94\x8c\x0c_reconstruct\x94\x93\x94\x8c\x05numpy\x94\x8c\x07ndarray\x94\x93\x94K\x00\x85\x94C\x01b\x94\x87\x94R\x94(K\x01K\x04K\x03K\x02\x87\x94h\x03\x8c\x05dtype\x94\x93\x94\x8c\x02u1\x94\x89\x88\x87\x94
```
likely benign LLM, confidence 0.85 Fixture bytes containing a pickled transposed numpy array for round-trip tests.
Reasoning
This literal is a pickle of a transposed contiguous array, a standard numpy serialization fixture. The reconstruct and dtype opcodes are expected for numpy's pickle format.
info ~~warn~~ → info by review payload-bytes-literal numpy/_core/tests/test_multiarray.py:5023:32

bytes literal contains 77 `\xNN` escapes (79% of content) — binary payload shape (ast pass, confidence 0.85)
```
        no_contiguous_dumped = b'\x80\x05\x95\x91\x00\x00\x00\x00\x00\x00\x00\x8c\x16numpy._core.multiarray\x94\x8c\x0c_reconstruct\x94\x93\x94\x8c\x05numpy\x94\x8c\x07ndarray\x94\x93\x94K\x00\x85\x94C\x01b\x94\x87\x94R\x94(K\x01K\x03K\x02\x86\x94h\x03\x8c\x05dtype\x94\x93\x94\x8c\x02u1\x94\x89\x88\x87\x94R\x94(K\x03\x
```
likely benign LLM, confidence 0.85 Fixture bytes containing a pickled non-contiguous numpy array.
Reasoning
Pickle fixture for a non-contiguous numpy array, used to test loading of older serialized forms. The content is numpy's own _reconstruct and dtype opcodes, consistent with a test vector.
info ~~warn~~ → info by review payload-bytes-literal numpy/_core/tests/test_multiarray.py:5083:13

concatenated bytes literal contains 32 `\xNN` escapes (56% of content) — binary payload shape (ast pass, confidence 0.85)
```
        s = (
            b"\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\n"
            b"ndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x04\x85cnumpy\n"
            b"dtype\nq\x04U\x02i1K\x00K\x01\x87Rq\x05(U\x01|NNJ\xff\xff\xff"
```
likely benign LLM, confidence 0.93 Test fixture containing a hand-built pickle byte string for numpy ndarray reconstruction.
Reasoning
The bytes literal is a hand-written pickle protocol 2 stream (numpy reconstruct, dtype i1 and a state tuple) used in a numpy test that checks unpickling of arrays from older numpy versions. The \xNN escapes are the pickle opcodes themselves, so the shape is expected for this purpose and no execution or exfiltration is involved.
info ~~warn~~ → info by review payload-bytes-literal numpy/_core/tests/test_multiarray.py:5094:13

concatenated bytes literal contains 39 `\xNN` escapes (60% of content) — binary payload shape (ast pass, confidence 0.85)
```
        s = (
            b"\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\n"
            b"ndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x04\x85cnumpy\n"
            b"dtype\nq\x04U\x02f4K\x00K\x01\x87Rq\x05(U\x01<NNJ\xff\xff\xff"
```
likely benign LLM, confidence 0.93 Test fixture holding a pickled numpy array with float32 dtype for compatibility testing.
Reasoning
Same pattern as the other fixtures: a pickle protocol 2 byte string encoding a numpy float32 dtype array for a backward-compatibility unpickling test. The escapes are pickle opcodes, not an encoded dropper.
info ~~warn~~ → info by review payload-bytes-literal numpy/_core/tests/test_multiarray.py:5106:13

concatenated bytes literal contains 34 `\xNN` escapes (54% of content) — binary payload shape (ast pass, confidence 0.85)
```
        s = (
            b"\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\n"
            b"ndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x02\x85cnumpy\n"
            b"dtype\nq\x04U\x02O8K\x00K\x01\x87Rq\x05(U\x01|NNJ\xff\xff\xff"
```
likely benign LLM, confidence 0.93 Test fixture with a pickled numpy object-dtype array for unpickle compatibility.
Reasoning
A pickle protocol 2 payload describing a numpy object dtype array, used in numpy's unpickling tests. It is test data with no decoding or execution step in the snippet.
info ~~warn~~ → info by review payload-bytes-literal numpy/_core/tests/test_multiarray.py:5119:13

concatenated bytes literal contains 34 `\xNN` escapes (57% of content) — binary payload shape (ast pass, confidence 0.85)
```
        s = (
            b"\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\n"
            b"ndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x01K\x04\x85cnumpy\n"
            b"dtype\nq\x04U\x02i1K\x00K\x01\x87Rq\x05(K\x01U\x01|NNJ\xff\xff"
```
likely benign LLM, confidence 0.93 Test fixture containing a pickled numpy array structure.
Reasoning
Pickle opcode bytes describing a numpy array reconstruction, consistent with the surrounding numpy pickle compatibility tests. It is static test data.
info ~~warn~~ → info by review payload-bytes-literal numpy/_core/tests/test_multiarray.py:5130:13

concatenated bytes literal contains 41 `\xNN` escapes (61% of content) — binary payload shape (ast pass, confidence 0.85)
```
        s = (
            b"\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\n"
            b"ndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x01K\x04\x85cnumpy\n"
            b"dtype\nq\x04U\x02f4K\x00K\x01\x87Rq\x05(K\x01U\x01<NNJ\xff\xff"
```
likely benign LLM, confidence 0.93 Test fixture with a pickled float32 numpy array.
Reasoning
Another pickle protocol 2 byte fixture for a numpy float32 array in a compatibility test. The byte density matches pickle opcodes and there is no runtime decoding of an obfuscated payload.
info ~~warn~~ → info by review payload-bytes-literal numpy/_core/tests/test_multiarray.py:5142:13

concatenated bytes literal contains 36 `\xNN` escapes (55% of content) — binary payload shape (ast pass, confidence 0.85)
```
        s = (
            b"\x80\x02cnumpy.core._internal\n_reconstruct\nq\x01cnumpy\n"
            b"ndarray\nq\x02K\x00\x85U\x01b\x87Rq\x03(K\x01K\x02\x85cnumpy\n"
            b"dtype\nq\x04U\x02O8K\x00K\x01\x87Rq\x05(K\x01U\x01|NNJ\xff\xff"
```
likely benign LLM, confidence 0.93 Test fixture with a pickled numpy object-dtype array.
Reasoning
Pickle fixture for a numpy object-dtype array used to test unpickling of older formats. It is static test input consistent with the rest of the file.
info ~~warn~~ → info by review decoder-import-with-exec numpy/_core/tests/test_records.py:184:23

file imports decoder module(s) pickle and calls `exec`/`eval`/`compile` — multi-stage payload shape (ast pass, confidence 0.80)
```
        recordarr_r = eval("np." + repr(recordarr), {'np': np})
        recarr_r = eval("np." + repr(recarr), {'np': np})
        # Prints the type `numpy.record` as part of the dtype:
```
likely benign LLM, confidence 0.85 Test file that evals repr strings of numpy record arrays to check round-tripping.
Reasoning
The file imports pickle and uses eval, but the flagged eval calls take repr() of numpy record arrays prefixed with 'np.' to test that repr round-trips. The pickle import is for other tests in the file. The combination is a test-suite pattern, not a multi-stage payload.
info ~~critical~~ → info by review dynamic-execution numpy/_core/tests/test_records.py:184:23

`eval` called on a constructed string (ast pass, confidence 0.80)
```
        recordarr_r = eval("np." + repr(recordarr), {'np': np})
        recarr_r = eval("np." + repr(recarr), {'np': np})
        # Prints the type `numpy.record` as part of the dtype:
```
likely benign LLM, confidence 0.92 eval of a repr-generated numpy expression in a record array test.
Reasoning
eval is applied to a string built from repr() of a numpy array that the test itself created, with a restricted globals dict containing only np. This is a repr round-trip check in a test, not attacker-controlled input.
info ~~critical~~ → info by review dynamic-execution numpy/_core/tests/test_records.py:185:20

`eval` called on a constructed string (ast pass, confidence 0.80)
```
        recordarr_r = eval("np." + repr(recordarr), {'np': np})
        recarr_r = eval("np." + repr(recarr), {'np': np})
        # Prints the type `numpy.record` as part of the dtype:
        recordview_r = eval("np." + repr(recordview), {'np': np, 'numpy': np})
```
likely benign LLM, confidence 0.92 eval of a repr-built recarray expression to verify type round-tripping.
Reasoning
The eval input is 'np.' concatenated with repr of a locally constructed recarray, and the test checks the resulting type. The input is generated in-process from trusted test values.
info ~~critical~~ → info by review dynamic-execution numpy/_core/tests/test_records.py:187:24

`eval` called on a constructed string (ast pass, confidence 0.80)
```
        # Prints the type `numpy.record` as part of the dtype:
        recordview_r = eval("np." + repr(recordview), {'np': np, 'numpy': np})

        assert_equal(type(recordarr_r), np.recarray)
```
likely benign LLM, confidence 0.92 eval of a repr-generated recordview expression in a numpy test.
Reasoning
Same repr round-trip eval for recordview in a numpy test, with a fixed globals dict and no external input.

info unicode-mixed-script numpy/_core/tests/test_regression.py:2634:51

identifier `ﬃ⁵Å` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

    def test_vectorize_fixed_width_string(self):
        arr = np.array(["SOme wOrd Ǆ ß ᾛ ΣΣ ﬃ⁵Å Ç Ⅰ"]).astype(np.str_)
        f = str.casefold
        res = np.vectorize(f, otypes=[arr.dtype])(arr)

info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_scalarmath.py:636:22

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
            val_repr = repr(val)
            val2 = t(eval(val_repr))
            if not (val2 == 0 and val < 1e-100):
                assert_equal(val, val2)
```
likely benign LLM, confidence 0.90 eval of a numeric repr string in a scalar math test.
Reasoning
eval(repr(val)) round-trips a numeric scalar value in a scalar math test to check float representation. The input is a number generated by the test, so the eval is not an injection vector.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_simd.py:244:16

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        data_a = self._load_b(data * self._nlanes())
        func = eval(intrin)
        intrin = getattr(self, intrin)
        desired = func(data_a)
```
likely benign LLM, confidence 0.85 eval used to look up a SIMD intrinsic function by name in a test.
Reasoning
eval(intrin) resolves an intrinsic name string that comes from the test's own parametrization, then calls it on test data. It is a dispatch pattern in a SIMD test, with no outside input in the snippet.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_simd.py:512:16

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        chk_nan = {"xp": 1, "np": 1, "nn": 2, "xn": 2}.get(intrin[-2:], 0)
        func = eval(intrin[:3])
        reduce_intrin = getattr(self, "reduce_" + intrin)
        intrin = getattr(self, intrin)
```
likely benign LLM, confidence 0.86 eval resolves a numpy SIMD intrinsic name inside a test method.
Reasoning
The eval argument is a slice of a test-parameter intrinsic name (intrin[:3]) drawn from the test's own hardcoded lists. It is a test-harness idiom for resolving names to numpy SIMD functions, not attacker-controlled input.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_simd.py:642:16

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        data_a = self.load(data * self.nlanes)
        func = eval(intrin)
        intrin = getattr(self, intrin)
        desired = func(data_a)
```
likely benign LLM, confidence 0.86 eval converts a test-defined intrinsic name into a callable.
Reasoning
eval(intrin) evaluates a symbolic intrinsic name from the test's internal parameter list, in a numpy SIMD test file. No external input reaches it.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_simd.py:703:43

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
            return
        npyv_load_tillz, npyv_load_till = eval(intrin)
        data = self._data()
        lanes = list(range(1, self.nlanes + 1))
```
likely benign LLM, confidence 0.86 eval resolves npyv load-till intrinsic names in a SIMD test.
Reasoning
eval(intrin) turns a test-defined name for a load-till intrinsic into functions. The source is the test suite's own constants, so it is a benign test pattern.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_simd.py:723:27

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
            return
        npyv_store_till = eval(intrin)
        data = self._data()
        data_rev = self._data(reverse=True)
```
likely benign LLM, confidence 0.86 eval resolves a store-till intrinsic name in a SIMD test.
Reasoning
Same test-harness pattern: eval on an internal intrinsic name string to get a store-till function. No untrusted input is involved.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_simd.py:743:22

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
            return
        npyv_loadn = eval(intrin)
        for stride in range(-64, 64):
            if stride < 0:
```
likely benign LLM, confidence 0.86 eval resolves a loadn intrinsic name in a SIMD test.
Reasoning
eval on a fixed test-defined intrinsic name to obtain a strided-load function. Benign test scaffolding.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_simd.py:769:45

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
            return
        npyv_loadn_tillz, npyv_loadn_till = eval(intrin)
        lanes = list(range(1, self.nlanes + 1))
        lanes += [self.nlanes**2, self.nlanes**4]
```
likely benign LLM, confidence 0.86 eval resolves a loadn-till intrinsic name in a SIMD test.
Reasoning
eval on an internal loadn-till intrinsic name from the test's own list. This is ordinary numpy test code.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_simd.py:806:23

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
            return
        npyv_storen = eval(intrin)
        data = self._data()
        vdata = self.load(data)
```
likely benign LLM, confidence 0.86 eval resolves a strided store intrinsic name in a SIMD test.
Reasoning
eval on a test-internal storen intrinsic name. No external input and no payload pattern.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_simd.py:845:28

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
            return
        npyv_storen_till = eval(intrin)
        data = self._data()
        vdata = self.load(data)
```
likely benign LLM, confidence 0.86 eval resolves a strided store-till intrinsic name in a SIMD test.
Reasoning
eval on a fixed internal storen-till intrinsic name, as part of the SIMD test harness.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_simd.py:897:18

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
            return
        intrin = eval(intrin)
        idx_itrin = getattr(self.npyv, f"setall_u{elsize}")
        table = range(table_size)
```
likely benign LLM, confidence 0.86 eval resolves an intrinsic name for a table-lookup SIMD test.
Reasoning
eval(intrin) on a test-defined intrinsic name for a lookup-table test. The string comes from the test's own parameterization.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_simd.py:1104:16

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        data_a = self.load(data * self.nlanes)
        func = eval(intrin)
        intrin = getattr(self, intrin)
        desired = func(data_a)
```
likely benign LLM, confidence 0.86 eval converts a test-defined intrinsic name into a callable.
Reasoning
Same pattern as the other test_simd eval calls: the string is an internal intrinsic name, and the result is called on test data.
info ~~warn~~ → info by review dynamic-attribute numpy/_core/tests/test_simd.py:1345:13

reach-by-name through `globals` (ast pass, confidence 0.60)
```
                pytest.mark.skip(reason=skip_m)(tcls)
            globals()[tcls.__name__] = tcls
```
likely benign LLM, confidence 0.80 Test-class generator registers classes into module globals.
Reasoning
globals() is used to register dynamically generated test classes under their names. This is a common pytest generation technique, with no network or payload behavior visible.

info unicode-homoglyph numpy/_core/tests/test_strings.py:1030:42

identifier `κόσμε` contains homoglyph candidates: κ (03BA)→k (in string/comment) (raw pass, confidence 0.35)

        ["hello", "world"],
        ['hello world', 'γεια σου κόσμε', '你好世界', '👋 🌍'],
    ])
    def test_slice(self, args, buf, dt):

info unicode-mixed-script numpy/_core/tests/test_strings.py:1030:42

identifier `κόσμε` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

        ["hello", "world"],
        ['hello world', 'γεια σου κόσμε', '你好世界', '👋 🌍'],
    ])
    def test_slice(self, args, buf, dt):

info unicode-mixed-script numpy/_core/tests/test_strings.py:1294:15

identifier `λμ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

        [
            ("λμ", "μ"),
            ("λμ", "λ"),
            ("λ" * 5 + "μ" * 2, "μ"),

info unicode-mixed-script numpy/_core/tests/test_strings.py:1295:15

identifier `λμ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

            ("λμ", "μ"),
            ("λμ", "λ"),
            ("λ" * 5 + "μ" * 2, "μ"),
            ("λ" * 5 + "μ" * 2, "λ"),

info unicode-mixed-script numpy/_core/tests/test_strings.py:1298:42

identifier `μλ` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

            ("λ" * 5 + "μ" * 2, "λ"),
            ("λ" * 5 + "A" + "μ" * 2, "μλ"),
            ("λμ" * 5, "μ"),
            ("λμ" * 5, "λ"),

info unicode-mixed-script numpy/_core/tests/test_strings.py:1299:15

identifier `λμ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

            ("λ" * 5 + "A" + "μ" * 2, "μλ"),
            ("λμ" * 5, "μ"),
            ("λμ" * 5, "λ"),
    ])

info unicode-mixed-script numpy/_core/tests/test_strings.py:1300:15

identifier `λμ` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

            ("λμ" * 5, "μ"),
            ("λμ" * 5, "λ"),
    ])
    def test_strip_functions_unicode(self, source, strip, method, dt):

info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_umath.py:513:26

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        lsize = 512 + 7
        a, b, divisors = eval(ex_val)
        a_lst, b_lst = a.tolist(), b.tolist()
```
likely benign LLM, confidence 0.85 eval builds test arrays from an expression string in a umath test.
Reasoning
eval(ex_val) evaluates a test-case expression string from the test's own data table to build arrays for division-accuracy checks. Benign test code.
info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_umath.py:576:13

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        fo = np.iinfo(dtype)
        a = eval(ex_val)
        lst = a.tolist()
        c_div = lambda n, d: (
```
likely benign LLM, confidence 0.85 eval builds a test array from an internal expression string.
Reasoning
eval(ex_val) on an internal test expression to produce an array for comparison. No external input is involved.

info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_umath_accuracy.py:75:48

`eval` called on a non-literal expression (ast pass, confidence 0.70)

                                                      data_type_str),
                                         dtype=eval(datatype))
                        outval = np.array(str_to_float(data_output_str,
                                                       data_type_str),

likely benign LLM, confidence 0.85 eval maps a bundled test-data dtype name to a numpy dtype.

Reasoning

eval(datatype) maps a dtype name read from numpy's bundled accuracy-test data files to a numpy dtype. The input is a bounded set of type names in test fixtures, so the risk is low.

info ~~warn~~ → info by review dynamic-execution numpy/_core/tests/test_umath_accuracy.py:78:49

`eval` called on a non-literal expression (ast pass, confidence 0.70)

                                                       data_type_str),
                                          dtype=eval(datatype))
                        perm = np.random.permutation(len(inval))
                        inval = inval[perm]

likely benign LLM, confidence 0.85 eval maps a test-data dtype name to a numpy dtype.

Reasoning

The same dtype eval on bundled accuracy-test data. It is a test-fixture idiom with no network or payload behavior.

info ~~critical~~ → info by review dynamic-import numpy/core/__init__.py:19:11

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
    # scipy.special.expit for instance.
    mod = __import__(module, fromlist=[name])
    return getattr(mod, name)
```
likely benign LLM, confidence 0.80 Legacy numpy.core shim imports a submodule dynamically to forward attributes.
Reasoning
This is a deprecation-forwarding shim: __import__ loads a fixed numpy submodule named in the module's own code and returns an attribute from it. Severity is critical only because __import__ is dynamic. The module name is not external input, so this is a legitimate pattern.
info ~~warn~~ → info by review dynamic-attribute numpy/core/_multiarray_umath.py:9:9

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    if isinstance(attr, ufunc):
        globals()[item] = attr
```
likely benign LLM, confidence 0.90 Copies ufunc objects into the module namespace via globals() during import.
Reasoning
The snippet is a standard numpy idiom that re-exports ufunc attributes into module globals by name, a common way to populate a module namespace from a loop. It is a legitimate pattern in a well-known library, with no network, decoding, or payload behaviour visible.
info ~~warn~~ → info by review dynamic-attribute numpy/core/multiarray.py:6:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
for item in ["_reconstruct", "scalar"]:
    globals()[item] = getattr(multiarray, item)

# Pybind11 (in versions <= 2.11.1) imports _ARRAY_API from the multiarray
```
likely benign LLM, confidence 0.90 Re-exports selected multiarray attributes into the module namespace by name.
Reasoning
The loop copies named attributes from the multiarray module into globals() to re-export them. This is a plain compatibility re-export, and the comment refers to pybind11 importing _ARRAY_API, which is a known, documented dependency.
info ~~warn~~ → info by review dynamic-execution numpy/f2py/capi_maps.py:159:17

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        with open(f2cmap_file) as f:
            d = eval(f.read().lower(), {}, {})
        f2cmap_all, f2cmap_mapped = process_f2cmap_dict(f2cmap_all, d, c2py_map, True)
        outmess('Successfully applied user defined f2cmap changes\n')
```
likely benign LLM, confidence 0.80 Evaluates a user f2cmap dictionary file with eval to load type mappings.
Reasoning
eval is applied to the contents of a user-supplied f2cmap configuration file, with empty globals and locals. This is a documented f2py feature for user type maps. The risk is real in principle, since eval on file contents runs arbitrary code, but the input is a developer-provided build configuration, not fetched or hidden content.
info ~~warn~~ → info by review dynamic-execution numpy/f2py/capi_maps.py:299:32

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        try:
            ret['size'] = repr(eval(ret['size']))
        except Exception:
            pass
```
likely benign LLM, confidence 0.85 Evaluates a Fortran array size expression to resolve its numeric value.
Reasoning
eval evaluates a size expression from Fortran declaration metadata, inside a try/except. This is ordinary expression evaluation in a Fortran-to-C wrapper generator.
info ~~warn~~ → info by review dynamic-execution numpy/f2py/capi_maps.py:447:25

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
                else:
                    v = eval(v, {}, {})
                    ret['init.r'], ret['init.i'] = str(v.real), str(v.imag)
            except Exception:
```
likely benign LLM, confidence 0.85 Evaluates a complex initialiser value to derive its real and imaginary parts.
Reasoning
eval is applied to an initialisation value for a complex constant, to split it into real and imaginary parts. The use is limited to parsing numeric expressions from Fortran sources and is wrapped in exception handling.
info ~~warn~~ → info by review decoder-import-with-exec numpy/f2py/crackfortran.py:1325:21

file imports decoder module(s) codecs and calls `exec`/`eval`/`compile` — multi-stage payload shape (ast pass, confidence 0.80)
```
            try:
                v = eval(initexpr, {}, params)
            except (SyntaxError, NameError, TypeError) as msg:
                errmess(f'analyzeline: Failed to evaluate {initexpr!r}. '
```
likely benign LLM, confidence 0.80 Evaluates Fortran parameter initialisation expressions inside the f2py source parser.
Reasoning
The file imports codecs and uses eval, which matches the multi-stage shape signal. In context, though, eval is only used to evaluate Fortran parameter initialisation expressions with restricted namespaces inside a Fortran parser. The codecs import is unrelated to any decode-then-exec chain, so this is a false positive from the shape heuristic.
info ~~warn~~ → info by review dynamic-execution numpy/f2py/crackfortran.py:1325:21

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
            try:
                v = eval(initexpr, {}, params)
            except (SyntaxError, NameError, TypeError) as msg:
                errmess(f'analyzeline: Failed to evaluate {initexpr!r}. '
```
likely benign LLM, confidence 0.85 Evaluates a Fortran initialisation expression with a params dictionary during parsing.
Reasoning
This is the same eval-on-Fortran-expression call as the paired finding. It is a standard parse-time evaluation within a try block, with a restricted params dictionary.
info ~~warn~~ → info by review dynamic-execution numpy/f2py/crackfortran.py:2274:9

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
    """ Like `eval` but returns only integers and floats """
    r = eval(e, g, l)
    if type(r) in [int, float]:
        return r
```
likely benign LLM, confidence 0.85 Helper that evaluates a Fortran expression and returns only int or float values.
Reasoning
The function is documented as eval-like and returns only int or float results. It evaluates Fortran numeric expressions, which is the purpose of the parser helper.
info ~~warn~~ → info by review dynamic-execution numpy/f2py/crackfortran.py:2562:17

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        # TODO: use symbolic from PR #19805
        value = eval(value, {}, params)
        value = (repr if isinstance(value, str) else str)(value)
    except (NameError, SyntaxError, TypeError):
```
likely benign LLM, confidence 0.85 Evaluates a Fortran parameter value with a local params dictionary.
Reasoning
eval evaluates a Fortran parameter value using a params dictionary and catches NameError, SyntaxError and TypeError. This is ordinary parameter resolution in the parser.
info ~~warn~~ → info by review dynamic-execution numpy/f2py/crackfortran.py:2639:29

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
                try:
                    l = str(eval(l, {}, params))
                except Exception:
                    pass
```
likely benign LLM, confidence 0.85 Resolves a Fortran length expression by evaluating it against parameters.
Reasoning
eval resolves a Fortran length or kind expression with a params dictionary, inside an exception handler. It is routine parser behaviour.
info ~~warn~~ → info by review dynamic-execution numpy/f2py/crackfortran.py:2648:29

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
                try:
                    l = str(eval(l, {}, params))
                except Exception:
                    pass
```
likely benign LLM, confidence 0.85 Resolves a Fortran expression to a string value using parameter bindings.
Reasoning
This is the same kind of parameter-expression evaluation as the neighbouring finding, with exception handling and a restricted namespace.
info ~~warn~~ → info by review dynamic-execution numpy/f2py/crackfortran.py:2916:58

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
                                try:
                                    kindselect['kind'] = eval(
                                        kindselect['kind'], {}, params)
                                except Exception:
```
likely benign LLM, confidence 0.85 Evaluates a Fortran kind selector expression against known parameters.
Reasoning
eval resolves a kind selector expression against the params dictionary, falling back on exception. This is part of normal Fortran kind handling.
info ~~warn~~ → info by review dynamic-execution numpy/f2py/crackfortran.py:2987:17

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        try:
            p = eval(v, g_params, params)
        except Exception as msg:
            p = v
```
likely benign LLM, confidence 0.85 Evaluates a Fortran parameter value and keeps the raw text if evaluation fails.
Reasoning
eval evaluates a Fortran parameter value with explicit globals and params, and falls back to the raw string on error. This is routine parameter handling.
info ~~warn~~ → info by review dynamic-execution numpy/f2py/crackfortran.py:3018:20

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        try:
            item = eval(item, g_params, params)
        except Exception as msg:
            outmess(f'param_eval: got "{msg}" on {item!r}\n')
```
likely benign LLM, confidence 0.85 Evaluates a parameter item and logs a message if evaluation fails.
Reasoning
eval evaluates a parameter item with explicit namespaces and logs failures through outmess. This is standard parser behaviour.
info ~~warn~~ → info by review dynamic-execution numpy/f2py/crackfortran.py:3470:25

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
                try:
                    v = eval(v)
                    v = f'({v.real},{v.imag})'
                except Exception:
```
likely benign LLM, confidence 0.85 Converts a complex constant from Fortran source into a formatted tuple.
Reasoning
eval converts a complex literal from Fortran source into a Python complex value for formatting. The input is limited to numeric source text, and the call sits inside a try/except.
info ~~warn~~ → info by review frame-introspection numpy/lib/_index_tricks_impl.py:346:21

`sys._getframe` — call-stack frame introspection (ast pass, confidence 0.70)
```
        if isinstance(key, str):
            frame = sys._getframe().f_back
            mymat = matrixlib.bmat(key, frame.f_globals, frame.f_locals)
            return mymat
```
likely benign LLM, confidence 0.90 Caller-frame introspection used by numpy's matrix string constructor.
Reasoning
sys._getframe in numpy's mgrid/bmat path is a legitimate use to fetch caller globals for matrix string parsing; no obfuscation or malicious behavior.
info ~~critical~~ → info by review dynamic-import numpy/lib/_utils_impl.py:172:14

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
def _makenamedict(module='numpy'):
    module = __import__(module, globals(), locals(), [])
    thedict = {module.__name__: module.__dict__}
    dictlist = [module.__name__]
```
likely benign LLM, confidence 0.90 Dynamic import of a module by name in numpy's utility helper.
Reasoning
__import__ on a module name parameter in numpy's _makenamedict is a standard utility for building a namespace dict of a named module; the argument is a caller-supplied module name, not hidden payload.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_c_lapack.c:2697:24

two identifiers collapse to visual skeleton `i|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer ie, il, mm;
    static real eps, anrm, bnrm;
    static integer itau, nlvl, iascl, ibscl;
```
likely benign LLM, confidence 0.95 Confusable-looking local identifiers in f2c-translated LAPACK C code.
Reasoning
Skeleton collision between short local variable names like ie/il/i/l is a normal artifact of f2c-generated Fortran-translated code with single-letter names; not an attack.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_c_lapack.c:9378:31

two identifiers collapse to visual skeleton `||` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer i__, j, k, ll, iq, lgn, msd2, smm1, spm1, spm2;
    static real temp;
    static integer curr, iperm;
```
likely benign LLM, confidence 0.95 f2c-generated local variable declarations in LAPACK.
Reasoning
Local variables i__, j, k, ll are standard f2c naming; the 'll' and 'i__' collision is a benign artifact of translation.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_c_lapack.c:9727:28

two identifiers collapse to visual skeleton `n|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer i__, k, n1, n2, iq, iw, iz, ptr, indx, curr, indxc, indxp;
    extern /* Subroutine */ int claed8_(integer *, integer *, integer *,
	    singlecomplex *, integer *, real *, real *, integer *, real *, real *,
```
likely benign LLM, confidence 0.95 f2c-generated LAPACK local declarations.
Reasoning
Standard f2c local variable names; confusable skeleton collision is incidental to the generated code.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_c_lapack.c:10032:36

two identifiers collapse to visual skeleton `n|p|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    static real s, t;
    static integer k2, n1, n2, jp, n1p1;
    static real eps, tau, tol;
    static integer jlam, imax, jmax;
```
likely benign LLM, confidence 0.95 f2c-generated LAPACK local declarations.
Reasoning
Ordinary f2c-translated local names; collision is a false positive from skeleton matching.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_c_lapack.c:16718:45

two identifiers collapse to visual skeleton `k|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer j, k, m, i2, j2, i4, j4, k1;
    static real h11, h12, h21, h22;
    static integer m22, ns, nu;
```
likely benign LLM, confidence 0.95 f2c-generated LAPACK local declarations.
Reasoning
Standard numerical-routine local variables in generated LAPACK code; no malicious construction.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_d_lapack.c:559:20

two identifiers collapse to visual skeleton `||` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    static doublereal r__, cs;
    static integer ll;
    static doublereal sn, mu;
    static integer nm1, nm12, nm13, lll;
```
likely benign LLM, confidence 0.95 f2c-generated LAPACK local declarations.
Reasoning
Ordinary f2c-generated local variable names in double-precision LAPACK; false positive from identifier skeleton matching.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_d_lapack.c:2647:63

two identifiers collapse to visual skeleton `v|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
/* Subroutine */ int dgeev_(char *jobvl, char *jobvr, integer *n, doublereal *
	a, integer *lda, doublereal *wr, doublereal *wi, doublereal *vl,
	integer *ldvl, doublereal *vr, integer *ldvr, doublereal *work,
	integer *lwork, integer *info)
```
likely benign LLM, confidence 0.95 dgeev function signature in generated LAPACK code.
Reasoning
Parameter names jobvl/jobvr/vl/vr in dgeev signature are standard LAPACK; collision is incidental.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_d_lapack.c:4061:24

two identifiers collapse to visual skeleton `i|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer ie, il, mm;
    static doublereal eps, anrm, bnrm;
    static integer itau, nlvl, iascl, ibscl;
```
likely benign LLM, confidence 0.95 f2c-generated LAPACK local declarations.
Reasoning
Standard f2c local names in LAPACK; no sign of hidden identifiers or payload.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_d_lapack.c:9134:28

two identifiers collapse to visual skeleton `n|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer i__, k, n1, n2, is, iw, iz, iq2, zpp1, indx, indxc;
    extern /* Subroutine */ int dcopy_(integer *, doublereal *, integer *,
	    doublereal *, integer *);
```
likely benign LLM, confidence 0.95 f2c-generated LAPACK local declarations.
Reasoning
Routine local variable names typical of translated LAPACK; benign collision.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_d_lapack.c:9366:54

two identifiers collapse to visual skeleton `n|p|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    static doublereal s, t;
    static integer k2, n2, ct, nj, pj, js, iq1, iq2, n1p1;
    static doublereal eps, tau, tol;
    static integer psm[4], imax, jmax;
```
likely benign LLM, confidence 0.95 f2c-generated LAPACK local declarations.
Reasoning
Standard LAPACK local declarations including psm array; skeleton collision is a false positive.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_d_lapack.c:12877:48

two identifiers collapse to visual skeleton `cs|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
/* Subroutine */ int dlaev2_(doublereal *a, doublereal *b, doublereal *c__,
	doublereal *rt1, doublereal *rt2, doublereal *cs1, doublereal *sn1)
{
    /* System generated locals */
```
likely benign LLM, confidence 0.95 dlaev2 signature in generated LAPACK code.
Reasoning
dlaev2 parameter names rt1/rt2/cs1/sn1 are standard LAPACK; collision is incidental to generated code.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_d_lapack.c:12877:65

two identifiers collapse to visual skeleton `sn|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
/* Subroutine */ int dlaev2_(doublereal *a, doublereal *b, doublereal *c__,
	doublereal *rt1, doublereal *rt2, doublereal *cs1, doublereal *sn1)
{
    /* System generated locals */
```
likely benign LLM, confidence 0.97 Parameter named sn1 in dlaev2_ collides in skeleton with another identifier in generated LAPACK code.
Reasoning
Auto-generated f2c LAPACK C code; the collision is between sn1 and a similarly shaped identifier in the same visual skeleton, a normal consequence of identifier naming in numerical code. No obfuscation or malicious behavior.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_d_lapack.c:13496:23

two identifiers collapse to visual skeleton `t|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    static integer i1, i2;
    static doublereal t1, t2, t3, v2, v3, aa, ab, ba, bb, h11, h12, h21, h22,
	    cs;
    static integer nh;
```
likely benign LLM, confidence 0.97 Static locals t1/t2 in generated LAPACK code flagged for confusable skeleton.
Reasoning
Static local variables t1, t2 in f2c-generated LAPACK routine; skeleton collision from digits in short names is a benign naming artifact.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_d_lapack.c:20362:50

two identifiers collapse to visual skeleton `k|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer i__, j, k, m, i2, j2, i4, j4, k1;
    static doublereal h11, h12, h21, h22;
    static integer m22, ns, nu;
```
likely benign LLM, confidence 0.97 Local variable declarations in generated LAPACK routine trigger a skeleton collision.
Reasoning
Standard generated LAPACK local variable declarations (h11, h12, k, etc.); collision is a naming artifact of short identifiers.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_s_lapack.c:554:20

two identifiers collapse to visual skeleton `||` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    static real r__, cs;
    static integer ll;
    static real sn, mu;
    static integer nm1, nm12, nm13, lll;
```
likely benign LLM, confidence 0.97 Local variables in generated sLAPACK routine flagged for identifier skeleton collision.
Reasoning
Generated single-precision LAPACK code with ordinary short local names; skeleton collision is an artifact of the confusable-character heuristic on short identifiers.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_s_lapack.c:563:23

two identifiers collapse to visual skeleton `sin|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    static integer isub, iter;
    static real unfl, sinl, cosr, smin, smax, sinr;
    extern /* Subroutine */ int srot_(integer *, real *, integer *, real *,
	    integer *, real *, real *), slas2_(real *, real *, real *, real *,
```
likely benign LLM, confidence 0.97 Local variable names sinl/sinr in generated LAPACK code collide in skeleton.
Reasoning
Standard f2c-generated declarations of sinl/sinr etc.; no evidence of homoglyph attack, just short names colliding in skeleton.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_s_lapack.c:2637:42

two identifiers collapse to visual skeleton `v|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
/* Subroutine */ int sgeev_(char *jobvl, char *jobvr, integer *n, real *a,
	integer *lda, real *wr, real *wi, real *vl, integer *ldvl, real *vr,
	integer *ldvr, real *work, integer *lwork, integer *info)
{
```
likely benign LLM, confidence 0.96 sgeev_ parameter names flagged for identifier skeleton collision in generated code.
Reasoning
Function parameter list of sgeev_ in generated LAPACK code; skeleton collision is a benign artifact of the heuristic.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_s_lapack.c:4037:24

two identifiers collapse to visual skeleton `i|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer ie, il, mm;
    static real eps, anrm, bnrm;
    static integer itau, nlvl, iascl, ibscl;
```
likely benign LLM, confidence 0.96 Local variables in generated LAPACK routine flagged by confusable-skeleton heuristic.
Reasoning
Generated LAPACK local variable declarations; short names like ie, il, mm collide in skeleton with no malicious content.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_s_lapack.c:9106:28

two identifiers collapse to visual skeleton `n|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer i__, k, n1, n2, is, iw, iz, iq2, cpp1, indx, indxc, indxp;
    extern /* Subroutine */ int scopy_(integer *, real *, integer *, real *,
	    integer *), slaed2_(integer *, integer *, integer *, real *, real
```
likely benign LLM, confidence 0.96 Local declarations in generated sLAPACK code flagged for skeleton collision.
Reasoning
Generated LAPACK local declarations with short names; collision is a heuristic artifact, not obfuscation.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_s_lapack.c:9334:54

two identifiers collapse to visual skeleton `n|p|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    static real s, t;
    static integer k2, n2, ct, nj, pj, js, iq1, iq2, n1p1;
    static real eps, tau, tol;
    static integer psm[4], imax, jmax, ctot[4];
```
likely benign LLM, confidence 0.96 Static local arrays in generated LAPACK routine flagged for skeleton collision.
Reasoning
Static arrays psm and ctot and other locals in generated LAPACK code; collision is a benign naming artifact.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_s_lapack.c:12835:13

two identifiers collapse to visual skeleton `cs|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
/* Subroutine */ int slaev2_(real *a, real *b, real *c__, real *rt1, real *
	rt2, real *cs1, real *sn1)
{
    /* System generated locals */
```
likely benign LLM, confidence 0.96 Parameters cs1/sn1 of slaev2_ flagged for skeleton collision in generated code.
Reasoning
Parameter of slaev2_ in generated LAPACK code; cs1 and sn1 naming is standard and the collision is a heuristic artifact.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_s_lapack.c:12835:24

two identifiers collapse to visual skeleton `sn|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
/* Subroutine */ int slaev2_(real *a, real *b, real *c__, real *rt1, real *
	rt2, real *cs1, real *sn1)
{
    /* System generated locals */
```
likely benign LLM, confidence 0.96 Parameter sn1 of slaev2_ flagged for skeleton collision in generated code.
Reasoning
Same slaev2_ parameter list; the collision reflects only short numeric-suffix identifiers in standard LAPACK code.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_s_lapack.c:13454:17

two identifiers collapse to visual skeleton `t|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    static integer i1, i2;
    static real t1, t2, t3, v2, v3, aa, ab, ba, bb, h11, h12, h21, h22, cs;
    static integer nh;
    static real sn;
```
likely benign LLM, confidence 0.96 Static locals in generated sLAPACK routine flagged for skeleton collision.
Reasoning
Generated LAPACK static locals t1, t2, cs, sn; heuristic false positive on short names.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_s_lapack.c:20285:50

two identifiers collapse to visual skeleton `k|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer i__, j, k, m, i2, j2, i4, j4, k1;
    static real h11, h12, h21, h22;
    static integer m22, ns, nu;
```
likely benign LLM, confidence 0.96 Local variable declarations in generated LAPACK code flagged for skeleton collision.
Reasoning
Generated LAPACK local variable declarations; short names collide in skeleton with no malicious signal.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_z_lapack.c:2712:24

two identifiers collapse to visual skeleton `i|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer ie, il, mm;
    static doublereal eps, anrm, bnrm;
    static integer itau, nlvl, iascl, ibscl;
```
likely benign LLM, confidence 0.95 Routine local variable declarations in a bundled f2c LAPACK source file.
Reasoning
Snippet shows ordinary f2c-translated LAPACK local variable declarations (ie, il, mm, itau...). The confusable collision of 'i|' skeleton comes from names like il/ie/i1 across scopes; a normal byproduct of Fortran-to-C naming, no obfuscation intent.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_z_lapack.c:9435:31

two identifiers collapse to visual skeleton `||` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer i__, j, k, ll, iq, lgn, msd2, smm1, spm1, spm2;
    static doublereal temp;
    static integer curr, iperm;
```
likely benign LLM, confidence 0.95 Local variable declarations in f2c-translated LAPACK divide-and-conquer routine.
Reasoning
Standard f2c-generated LAPACK locals (i__, j, k, ll, iq...) with identifier names that normally collide visually like l and 1 in Fortran-derived code. Benign.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_z_lapack.c:9783:28

two identifiers collapse to visual skeleton `n|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer i__, k, n1, n2, iq, iw, iz, ptr, indx, curr, indxc, indxp;
    extern /* Subroutine */ int dlaed9_(integer *, integer *, integer *,
	    integer *, doublereal *, doublereal *, integer *, doublereal *,
```
likely benign LLM, confidence 0.95 Local variables and extern prototype in translated LAPACK code.
Reasoning
Typical f2c LAPACK local declarations and extern prototypes; visual skeleton collision is an artifact of short Fortran-style names.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_z_lapack.c:10091:36

two identifiers collapse to visual skeleton `n|p|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    static doublereal s, t;
    static integer k2, n1, n2, jp, n1p1;
    static doublereal eps, tau, tol;
    static integer jlam, imax, jmax;
```
likely benign LLM, confidence 0.95 Local variables in translated LAPACK routine.
Reasoning
Ordinary f2c LAPACK local variable declarations; collision is a naming artifact.
info ~~warn~~ → info by review identifier-confusable-collision numpy/linalg/lapack_lite/f2c_z_lapack.c:16813:45

two identifiers collapse to visual skeleton `k|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    /* Local variables */
    static integer j, k, m, i2, j2, i4, j4, k1;
    static doublereal h11, h12, h21, h22;
    static integer m22, ns, nu;
```
likely benign LLM, confidence 0.95 Local variables in translated LAPACK eigenvalue routine.
Reasoning
Standard translated LAPACK Hessenberg-routine locals (h11, h12, m22, ns, nu). No malicious shape.
info ~~warn~~ → info by review frame-introspection numpy/matrixlib/defmatrix.py:1098:21

`sys._getframe` — call-stack frame introspection (ast pass, confidence 0.70)
```
            # get previous frame
            frame = sys._getframe().f_back
            glob_dict = frame.f_globals
            loc_dict = frame.f_locals
```
likely benign LLM, confidence 0.90 Caller-frame lookup in numpy matrix string parsing.
Reasoning
NumPy's matrix constructor uses sys._getframe().f_back to read caller globals for the matrix() string-to-matrix parsing helper; a well-known legitimate pattern in numpy's own code.
info ~~warn~~ → info by review identifier-confusable-collision numpy/random/src/distributions/distributions.c:624:28

two identifiers collapse to visual skeleton `x|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
                                   double p, binomial_t *binomial) {
  double r, q, fm, p1, xm, xl, xr, c, laml, lamr, p2, p3, p4;
  double a, u, v, s, F, rho, t, A, nrq, x1, x2, f1, f2, z, z2, w, w2, x;
  RAND_INT_TYPE m, y, k, i;
```
likely benign LLM, confidence 0.95 Local variable declarations in binomial distribution sampler.
Reasoning
Local double/RAND_INT_TYPE declarations in the binomial sampler (BTPE algorithm); single-letter names produce the collision. Benign.
info ~~warn~~ → info by review identifier-confusable-collision numpy/random/src/legacy/legacy-distributions.c:25:15

two identifiers collapse to visual skeleton `x|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
  } else {
    double f, x1, x2, r2;

    do {
```
likely benign LLM, confidence 0.95 Local variable declarations in legacy random distribution code.
Reasoning
Local variables in a Box-Muller/polar-method style legacy distribution routine; collision is incidental.
info ~~warn~~ → info by review macro-keyword-override numpy/random/src/mt19937/mt19937.h:6:1

`#define inline` rebinds the reserved C keyword `inline` (token pass, confidence 0.85)
```
#if defined(_WIN32) && !defined (__MINGW32__)
#define inline __forceinline
#endif
```
likely benign LLM, confidence 0.97 Windows-only macro mapping inline to __forceinline.
Reasoning
Conditional redefinition of inline to __forceinline on MSVC, a standard portability macro in numpy's random headers. Not a real obfuscation.
info ~~warn~~ → info by review macro-keyword-override numpy/random/src/pcg64/pcg64.h:60:1

`#define inline` rebinds the reserved C keyword `inline` (token pass, confidence 0.85)
```
#if defined(_WIN32) && !defined (__MINGW32__)
#define inline __forceinline
#endif
```
likely benign LLM, confidence 0.97 Windows-only macro mapping inline to __forceinline.
Reasoning
Same MSVC compatibility macro for inline, guarded by _WIN32 and not MinGW. Benign.
info ~~warn~~ → info by review dynamic-execution numpy/testing/_private/utils.py:1352:5

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
def runstring(astr, dict):
    exec(astr, dict)
```
likely benign LLM, confidence 0.90 Test helper executing a string of Python code in a given dict.
Reasoning
runstring is numpy's test helper that execs a supplied code string into a namespace; exec on a non-literal is its purpose, and the test utility is not hidden from users.
info ~~critical~~ → info by review frame-introspection numpy/testing/_private/utils.py:1451:13

`sys._getframe` — call-stack frame introspection — file also calls `sys.exit`/`exec`/`eval` (anti-analysis shape) (ast pass, confidence 0.85)
```
    if filename is None:
        f = sys._getframe(1)
        filename = f.f_globals['__file__']
    name = os.path.splitext(os.path.basename(filename))[0]
```
likely benign LLM, confidence 0.90 Retrieves caller module __file__ via sys._getframe in a testing utility.
Reasoning
Caller-frame lookup to derive a test module's filename for decorator/test naming, a common testing idiom. The critical severity reflects the anti-analysis heuristic keyword co-occurrence, not actual evasion here.
info ~~critical~~ → info by review frame-introspection numpy/testing/_private/utils.py:1632:13

`sys._getframe` — call-stack frame introspection — file also calls `sys.exit`/`exec`/`eval` (anti-analysis shape) (ast pass, confidence 0.85)
```
    """
    frame = sys._getframe(1)
    locs, globs = frame.f_locals, frame.f_globals
```
likely benign LLM, confidence 0.90 Caller frame locals/globals access in numpy's test timing helper.
Reasoning
Frame introspection to access caller locals and globals for assert-style code evaluation in the testing module (assert_ with a code string), legitimate test infrastructure.
info ~~warn~~ → info by review dynamic-execution numpy/testing/_private/utils.py:1635:12

`compile` called on a non-literal expression (ast pass, confidence 0.70)
```
    code = compile(code_str, f'Test name: {label} ', 'exec')
    i = 0
    elapsed = jiffies()
```
likely benign LLM, confidence 0.90 Compiles test code string for timed execution in numpy testing utilities.
Reasoning
compile of a generated test code string in the numpy test timing utility (assert_no_gc or similar runner); benign test infrastructure.
info ~~critical~~ → info by review frame-introspection numpy/testing/_private/utils.py:2790:17

`sys.settrace` — call-stack frame introspection — file also calls `sys.exit`/`exec`/`eval` (anti-analysis shape) (ast pass, confidence 0.85)
```
            try:
                sys.settrace(None)
                return func(*args, **kwargs)
            finally:
```
likely benign LLM, confidence 0.90 Temporarily clears trace function around test function call.
Reasoning
sys.settrace(None) inside a try/finally in a test decorator that disables a tracer temporarily, used to run functions without coverage/tracing interference. Legitimate testing code, flagged only by the keyword co-occurrence heuristic.
info ~~critical~~ → info by review frame-introspection numpy/testing/_private/utils.py:2793:17

`sys.settrace` — call-stack frame introspection — file also calls `sys.exit`/`exec`/`eval` (anti-analysis shape) (ast pass, confidence 0.85)
```
            finally:
                sys.settrace(original_trace)
        return wrapper
```
likely benign LLM, confidence 0.95 A numpy testing decorator that saves, disables, and restores the trace function via sys.settrace in a finally block.
Reasoning
The snippet shows sys.settrace(original_trace) being restored in a finally block inside a wrapper function. This is the standard pattern for a test decorator that temporarily disables a trace function and then restores the previous one. Nothing here hides code or evades analysis. The critical severity comes from the anti-analysis heuristic matching sys.exit/exec/eval elsewhere in the file, which is a weak signal in numpy's testing utilities.
info identifier-low-length numpy/typing/tests/data/pass/flatiter.py:1:1

23 of 39 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)

info dynamic-execution tools/list_numpy_dlls.sh:5:16

command name is a variable (`$py_ver`) that this file sets only to plain text (ast pass, confidence 0.40)

py_ver=${1}
site_packages=`python${py_ver} -m pip show numpy | \
		    grep Location | cut -d " " -f 2 -`;
dll_list=`for name in $(python${py_ver} -m pip show -f numpy | \

info dynamic-execution tools/list_numpy_dlls.sh:7:25

command name is a variable (`$py_ver`) that this file sets only to plain text (ast pass, confidence 0.40)

		    grep Location | cut -d " " -f 2 -`;
dll_list=`for name in $(python${py_ver} -m pip show -f numpy | \
			     grep -E -e '\.dll$'); do echo ${site_packages}/${name}; done`
echo ${dll_list}

info ~~critical~~ → info by review dynamic-import tools/refguide_check.py:586:9

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
        __import__(module_name)
        module = sys.modules[module_name]
```
likely benign LLM, confidence 0.95 A numpy docs-checking developer script that dynamically imports a package module by name and reads it from sys.modules.
Reasoning
tools/refguide_check.py is a numpy developer tool that checks docstring references. Calling __import__(module_name) and then reading sys.modules[module_name] is a normal way to import modules by name when walking the package tree. The module name comes from the project's own package listing, not from untrusted input or remote data. The pattern is typical of dev tooling and is not a dropper or obfuscation.

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.1.0
git clone https://github.com/numpy/numpy numpy && cd numpy
git checkout v2.5.4
disclude scan --severity info --diff v2.5.3 .