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: 1825 scanned, 417 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 19 warn · 119 info
Scan time: 79.5 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): the 100 most severe of 119 warn and critical signals (100 with a verdict); 100 demoted to info. The rest are unreviewed.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-14 18:14

Signals

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

warn 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 */
```
warn 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;
```
warn 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;
```
warn 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;
```
warn 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;
```

warn 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 *,

warn 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;
```
warn 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;
```

warn 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

warn 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;

warn 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 {
```
warn 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
```
warn 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
```
warn 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)
```
warn 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()
```

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 runs generated benchmark code into a namespace and extracts a run function.
Reasoning
exec of a code string into a namespace inside an asv benchmark setup is a common pattern for generating benchmark functions; the code is local source, not attacker-supplied.
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.85 Sphinx conf.py dynamically imports optional extension modules by name.
Reasoning
Sphinx conf.py importing extension names from a configured list in a try block is standard documentation build logic; the critical severity 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 numpy __init__ copies attributes from _core into module globals.
Reasoning
Populating module globals from core attributes to re-export names is a normal namespace-building idiom in numpy's package init.
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 template engine inspects caller frame to resolve template namespace.
Reasoning
Tempita templating uses sys._getframe to find caller namespace for template rendering; this is a legitimate template engine feature, not anti-analysis, and the co-occurrence with exec/eval reflects the template engine's own design.
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.90 Tempita evaluates template expressions in its namespace.
Reasoning
eval within the Tempita template expression evaluator is the template language's core function, evaluating template expressions in a controlled namespace.
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.90 Tempita executes template code blocks in its namespace.
Reasoning
exec of template statements is the core of the Tempita template engine, a vendored build utility.
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.85 Tempita CLI evaluates variable values passed as arguments.
Reasoning
eval of a command-line variable value in the Tempita CLI is an expected template-tool behavior; it runs only with developer-supplied arguments during build.
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 Dynamically imports a module by name to wrap a function for docstring substitution.
Reasoning
Dynamic import of a module and getattr to attach a docstring-decorated function is a known numpy idiom for array function-like docs; the place and obj values are internal constants.
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);
```
dismissed LLM, confidence 0.90 Short variable names xl and yl in a standard mulhi routine flagged as confusable.
Reasoning
The identifiers xl and yl are ordinary short names; the skeleton collision with x and y is an artifact of the confusable-skeleton heuristic on single-letter names, not homoglyph obfuscation.
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);
```
dismissed LLM, confidence 0.90 Short variable name yl flagged as confusable with y.
Reasoning
Same as the sibling finding: yl and y are normal identifiers whose skeleton collision is a heuristic false positive on short names.
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.80 Exports scalar type names into the module namespace and __all__.
Reasoning
Assigning type names into module globals and appending to __all__ is a standard way numpy exports its 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);
}
```
dismissed LLM, confidence 0.90 SIMD temporaries ab0 and ab1 flagged as confusable.
Reasoning
ab0 and ab1 are ordinary SIMD temporaries; the confusable skeleton match comes from trailing digits, 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);
```
dismissed LLM, confidence 0.90 SIMD temporaries ab0 and ab1 flagged as confusable.
Reasoning
Same ab0/ab1 naming in an AVX-512 intrinsic routine; a benign heuristic collision on digit suffixes.
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.85 Short SIMD parameter names ab0/ab1 collide visually under confusable skeleton matching.
Reasoning
Token-pass confusable collision between identifiers ab0/ab1 style names in a SIMD header; this is a natural naming artifact of short variable names, not an attack. The skeleton collision is an unlikely-intent coincidence.
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.85 Short local identifiers in a NumPy C function trigger a confusable-skeleton warning.
Reasoning
Identifiers a0 and out/ao-style short names in C code produce a confusable skeleton collision; typical of short local names in NumPy C sources, no malicious payload shown.
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.85 Timsort pointer variables pl/pi trigger a confusable-identifier warning.
Reasoning
Pointer variables pl, pi, pj, pr are standard timsort naming; the 'p|' skeleton collision is a false positive from short identifiers.
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.85 Generic timsort pointer variables trigger a confusable-identifier warning.
Reasoning
Same standard timsort pointer naming as the header variant; benign short identifiers with no obfuscation evidence.
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;
    }
```
likely benign LLM, confidence 0.80 sscanf with %n in a literal format string used to track parse offset in rational test code.
Reasoning
The %n directive in sscanf is a format-string conversion that stores the consumed character count into &offset; this is a standard, safe way to track parse position in a test module. It is not a format-string write exploit since the format is a literal and the target is a local int.
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;
    }
```
likely benign LLM, confidence 0.80 Second sscanf %n usage in rational test parser with a literal format and local offset.
Reasoning
Same literal sscanf pattern with %n storing into a local offset variable; a legitimate parsing idiom, flagged only by a naive pattern match.

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 asserts that eval of an array's repr reconstructs the array.
Reasoning
In a NumPy test file, eval of repr output round-trips arrays to verify printing; the input is self-generated test data, not untrusted input.
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 evaluates repr of a scalar-array element to verify round-trip printing.
Reasoning
Same repr round-trip test pattern in a test suite; eval operates on locally generated repr strings with a restricted namespace.
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 Dtype string round-trip test uses eval and pickle imports in a test module.
Reasoning
The decoder-import flag is generic: this is a dtype repr round-trip test. Pickle import here is a test utility and eval operates on str(dt) from a local dtype, not an external payload.
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 Dtype string round-trip test evaluates str(dt) produced locally.
Reasoning
Eval of str(dtype) in a unit test verifying dtype string round-trip; self-generated input with no external data path.
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 Multiarray test evaluates array repr round-trip and uses pickle in the same file.
Reasoning
Test evaluates repr of a local array with a restricted namespace to verify round-trip; pickle import is part of ordinary serialization tests.
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 Multiarray test evaluates repr of a locally constructed array.
Reasoning
Eval of repr(xx) in a test with a controlled namespace; no untrusted input reaches eval.
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.94 Test fixture containing a pickled numpy array (C-contiguous) used for serialization tests.
Reasoning
The bytes literal is a pickle protocol-5 stream reconstructing a numpy ndarray via numpy._core.numeric._frombuffer with a buffer of sequential bytes. This is a serialized test fixture for numpy's contiguity and pickling tests, in a numpy test file. Its high escape density is expected for binary pickle data and it is not executed as a payload.
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.94 Test fixture containing a pickled F-contiguous numpy array for serialization tests.
Reasoning
Same structure as the neighbouring fixture: a pickle stream reconstructing a Fortran-contiguous numpy array via _frombuffer. It is test data for numpy's pickling behaviour inside the numpy test suite.
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.94 Test fixture containing a pickled transposed numpy array.
Reasoning
The literal is a pickle stream using numpy._core.multiarray._reconstruct to rebuild a transposed ndarray. It is a regression fixture for numpy array pickling in its own test module, with no execution path to a payload.
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.94 Test fixture containing a pickled non-contiguous numpy array.
Reasoning
A pickle stream reconstructing a non-contiguous numpy ndarray via _reconstruct and dtype objects. This is numpy's own serialization test data, and the bytes are only loaded in tests.
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 Legacy pickle fixture for an int8 numpy array used in compatibility tests.
Reasoning
A concatenated bytes literal forming a legacy protocol-2 pickle of a numpy array (numpy.core._internal._reconstruct, dtype i1). It is a backward-compatibility test fixture for loading old numpy pickles, inside numpy's test suite.
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 Legacy pickle fixture for a float32 numpy array used in compatibility tests.
Reasoning
Legacy protocol-2 pickle of a float32 numpy array (dtype f4) built from concatenated bytes literals. This is compatibility test data for numpy's unpickling of older formats.
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 Legacy pickle fixture for an object-dtype numpy array used in compatibility tests.
Reasoning
Legacy protocol-2 pickle of an object-dtype (O8) numpy array, a standard compatibility fixture in numpy's test suite. The bytes are data, not code, and are only parsed by numpy tests.
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 Legacy pickle fixture for a Fortran-ordered int8 numpy array.
Reasoning
Legacy protocol-2 pickle of an int8 numpy array with a Fortran-order layout, used as test input for numpy's pickle compatibility checks. The high escape ratio is characteristic of binary pickle fixtures.
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 Legacy pickle fixture for a Fortran-ordered float32 numpy array.
Reasoning
Legacy protocol-2 pickle of a Fortran-ordered float32 numpy array, a numpy test fixture for loading older pickled arrays. It is benign binary test data.
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"
```
dismissed LLM, confidence 0.90 Test fixture containing a hand-written pickle byte string for numpy ndarray reconstruction.
Reasoning
A bytes literal of pickle protocol-2 data used as a test fixture for unpickling numpy arrays. The binary shape is expected for a pickle compatibility test and nothing in the snippet runs it maliciously.
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 helper that round-trips numpy record array reprs through eval.
Reasoning
The file is a numpy test module. The eval calls rebuild array reprs in the np namespace to check round-tripping. The pickle import is part of the test suite's serialization checks, 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:
```
dismissed LLM, confidence 0.90 eval of a repr-built expression to verify numpy record repr round-trips.
Reasoning
eval is applied to "np." plus repr of a locally created numpy array, with np as the only name in scope. This is a deliberate 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})
```
dismissed LLM, confidence 0.90 eval of a repr-built expression to verify numpy recarray repr round-trips.
Reasoning
Same pattern as the sibling finding: eval over a string built from repr of test-local arrays with a restricted namespace. Legitimate test code.
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)
```
dismissed LLM, confidence 0.90 eval of a repr-built expression for a recordview round-trip test.
Reasoning
eval on repr(recordview) with np in the namespace, inside a repr round-trip assertion in a test. No external input reaches it.

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)
```
dismissed LLM, confidence 0.90 eval of a scalar's repr to compare the round-tripped value in a test.
Reasoning
eval(repr(val)) recovers a scalar value from its repr for comparison in a scalar math test. The input is a test-generated float, so this is benign.
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 resolves a SIMD intrinsic name from test parameters to a callable.
Reasoning
intrin is an intrinsic name taken from the test's own parametrized list. eval resolves it to a numpy SIMD function for comparison. This is a common pattern in numpy's SIMD tests.
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.85 eval of a test-defined intrinsic name prefix to select a SIMD function.
Reasoning
eval(intrin[:3]) takes a prefix of a test-defined intrinsic name to get a function. The input is internal test data, not external.
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.85 eval resolves a test-supplied SIMD intrinsic name to a function.
Reasoning
Same SIMD test pattern: eval resolves a test-supplied intrinsic name to a callable used for expected-value computation.
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.85 eval resolves test-defined SIMD load intrinsic names to functions.
Reasoning
eval unpacks a tuple of load intrinsics named in the test's own data. It is consistent with the numpy SIMD test harness.
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.85 eval resolves a test-defined SIMD store intrinsic name to a function.
Reasoning
eval retrieves a store intrinsic named by the test's parameter list. Internal test data only.
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.85 eval resolves a test-defined strided-load intrinsic name to a function.
Reasoning
eval of a test-defined loadn intrinsic name in a SIMD strided-load test. No external input is involved.
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.85 eval of an intrinsic name string inside a SIMD load test.
Reasoning
The eval'd string is an intrinsic name from the test's own parametrization of NumPy SIMD intrinsics, inside a unit test. No external input reaches it, so this is a test-harness pattern rather than dropper behavior.
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.85 eval of an intrinsic name to obtain a store function in a test.
Reasoning
Same pattern: eval resolves a locally defined intrinsic name in a test method. The string comes from the test's own tables, not from untrusted input.
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.85 eval of an intrinsic name for a partial-store test.
Reasoning
Same test-harness eval of a fixed intrinsic name string; no untrusted source is visible.
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.85 eval of an intrinsic name in a lookup-table test.
Reasoning
eval on a test-supplied intrinsic name, followed by getattr on the module. Both operate on fixed test data within a unit test.
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.85 eval of a function name string to compute expected SIMD output.
Reasoning
eval resolves a reference function name used only to compute the expected result in a test. This is standard test parametrization.
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.90 Registers dynamically generated SIMD test classes into module globals.
Reasoning
Writing generated test classes into globals() is a common way for pytest to register dynamically built test cases. The key is the class's own __name__, so there is no hidden payload.

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 of a test expression string that builds integer arrays for division tests.
Reasoning
eval of ex_val in a test that unpacks arrays and divisors from parametrized expression strings. The strings are test constants, not attacker-controlled input.
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 of a test expression string to build an array for division checks.
Reasoning
Same test-parametrization eval producing an array for integer division checks; the input is local test data.
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.80 eval of a dtype string taken from accuracy test data.
Reasoning
eval resolves a dtype name read from bundled accuracy-test data files. This is a test-data convention, although eval on file contents would be risky in untrusted contexts. The data is shipped with the project.

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.80 eval of a dtype string from accuracy test data.

Reasoning

Same eval of a dtype name from bundled test data, used to build an input array for accuracy checks.

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.75 __import__ of a module name in a numpy.core backward-compatibility shim.
Reasoning
This is a compatibility shim that imports numpy._core submodules by name when legacy numpy.core attributes are accessed. The module names come from a fixed internal mapping, so the critical severity reflects the non-literal __import__ rule rather than real risk. The surrounding code is not shown, which limits confidence somewhat.
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 Re-exports ufunc attributes into module globals for compatibility.
Reasoning
This re-exports ufunc attributes from the private module into globals() for backward-compatible names. It is a standard NumPy forwarding pattern with no external input.
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 Copies a fixed set of names from multiarray into module globals for compatibility.
Reasoning
A fixed list of names is copied from the multiarray module into globals() for backward compatibility. Nothing external is involved.
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 eval of the contents of a user-provided f2cmap file to build a type-mapping dictionary.
Reasoning
The eval reads a user-supplied f2cmap configuration file that f2py is explicitly designed to load. Evaluating that dict literal is a documented tool feature, not a payload. The risk is that the tool trusts its input, not that it hides anything. Empty globals and locals limit the scope somewhat.
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.90 eval of a Fortran array-size expression string during C type mapping.
Reasoning
The eval evaluates a size expression taken from Fortran declaration metadata inside a try/except. This is parsing of Fortran dimension expressions, a routine code-generation step. Nothing suggests obfuscation.
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.90 eval of a complex-number initializer string to extract its real and imaginary parts.
Reasoning
The eval converts a Fortran complex initializer value into real and imaginary parts, and failures are caught. This is ordinary numeric parsing for generated wrappers.
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.85 Fortran parameter initializer evaluation in a file that also imports codecs for source decoding.
Reasoning
The file-level heuristic flags the combination of a codecs import and eval. In crackfortran.py, codecs is used for reading Fortran source encodings, and the eval is a Fortran parameter-initialization expression evaluator. The multi-stage payload shape does not match the code here.
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.90 eval of a Fortran PARAMETER initialization expression against a parameter dictionary.
Reasoning
This is the same eval of a Fortran initialization expression in a try block, with specific exceptions caught. It is the standard parameter-evaluation path of the Fortran parser.
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.90 Helper that evaluates Fortran constant expressions and returns only int or float results.
Reasoning
The function is documented as a restricted eval that returns only int or float results. It evaluates Fortran constant expressions, and the type check limits the output. The pattern is intentional and benign.
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.90 eval of a Fortran parameter value expression against the local params table.
Reasoning
The eval evaluates a parameter value expression against a params dictionary, and the caught exceptions fall back to the raw value. This is Fortran parameter resolution with no sign of malice.
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.90 eval of a Fortran length expression, with the result stringified and failures ignored.
Reasoning
The eval evaluates a length or kind expression with a params namespace and suppresses exceptions. This is routine handling of Fortran declarations.
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.90 eval of a second Fortran length or kind expression with the same params namespace.
Reasoning
This repeats the same pattern as the previous eval, evaluating a Fortran expression against params with exceptions suppressed. It is standard parser behavior.
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.90 eval of a Fortran KIND selector expression against the parameter table.
Reasoning
The eval resolves a KIND selector expression for a Fortran declaration against the params dictionary. It is a legitimate step in parsing Fortran type specifications.
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.90 eval of a Fortran parameter value with global and local parameter namespaces.
Reasoning
The eval resolves a parameter value using the global and local parameter dictionaries and falls back to the raw string on error. This is consistent with Fortran 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.90 eval of a parameter item against global and local namespaces, logging errors on failure.
Reasoning
The eval resolves parameter items with the same namespaces, and exceptions are logged rather than hidden. This is a normal part of the Fortran parser.
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 f2py evaluates a parameter value expression to format a complex number.
Reasoning
eval on a Fortran parameter value string to convert complex literals; it is a known legacy pattern in f2py, operating on parsed declaration values rather than attacker-controlled input in a meaningful sense, though eval is still risky.
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 numpy's matrix string shorthand reads the caller's frame globals and locals.
Reasoning
sys._getframe used by mgrid/bmat-style string matrix construction to access caller namespace; a documented, legitimate numpy idiom.
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 Helper imports a module by name to build a namespace dictionary for lookup.
Reasoning
__import__ on a module name parameter defaulting to 'numpy' inside numpy's own utility for building a name dictionary; the non-literal is a developer-supplied module name, not an obfuscated 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;
```
dismissed LLM, confidence 0.95 Local variable names in auto-translated LAPACK code look confusable under the skeleton heuristic.
Reasoning
Identifier collisions like 'ie', 'il', 'i__' are artifacts of f2c-generated LAPACK code where distinct names differ only by l/1/I or similar; the skeleton collision is a false positive from mechanical translation of Fortran names.
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;
```
dismissed LLM, confidence 0.95 Generated LAPACK locals share a visual skeleton under confusable-character folding.
Reasoning
Short generated Fortran-style local names collide visually; this is normal f2c output with no hostile intent.
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 *,
```
dismissed LLM, confidence 0.95 Short generated local identifiers flagged as confusable collisions.
Reasoning
Typical f2c-generated local variable declarations; the skeleton match is a heuristic false positive on short identifiers.
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;
```
dismissed LLM, confidence 0.95 Short LAPACK local variable names collide under skeleton folding.
Reasoning
Generated numerical code with short variable names; no homoglyph or deceptive identifiers evident.
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;
```
dismissed LLM, confidence 0.95 Local variable names in translated LAPACK code trigger a confusable collision.
Reasoning
Standard f2c-translated local variables; collision is an artifact of the heuristic on short names.
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;
```
dismissed LLM, confidence 0.95 Short generated local names in LAPACK code match under confusable folding.
Reasoning
Generated double-precision LAPACK locals; the skeleton collision is a benign artifact of short identifiers.
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)
```
dismissed LLM, confidence 0.95 Function parameter names in generated LAPACK signature collide under skeleton folding.
Reasoning
Parameter names in f2c-generated dgeev signature; no evidence of deception, only heuristic collision.
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;
```
dismissed LLM, confidence 0.95 Generated LAPACK local names trigger confusable identifier heuristic.
Reasoning
Same generated LAPACK local variable pattern; benign heuristic false positive.
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.90 f2c-translated LAPACK local variable declarations with short names.
Reasoning
Token pass collision of short Fortran-derived identifiers (n1, n2 vs n1 variants, skeleton 'n|') in f2c-generated LAPACK code; standard machine-translated naming, no malicious construct.
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;
```
dismissed LLM, confidence 0.95 Static local variables in an f2c-translated LAPACK routine whose names collapse to the same visual skeleton.
Reasoning
The flagged names are ordinary LAPACK local variables (n1p1, npsm-style names) in an f2c-generated numerical routine. The token-pass confusable skeleton collision is an artifact of short lowercase identifiers and has no obfuscation or malicious signal.
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 */
```
dismissed LLM, confidence 0.95 Parameter cs1 in the f2c-generated dlaev2_ eigenvalue routine, colliding with another identifier only under confusable-character normalization.
Reasoning
dlaev2_ is a standard LAPACK symmetric 2x2 eigensolver with parameters cs1 and sn1 (cosine and sine). Their skeleton collision is a naming coincidence in generated numerical code, not a sign of tampering.
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 */
```
dismissed LLM, confidence 0.95 Parameter sn1 in the f2c-generated dlaev2_ routine, flagged only for a skeleton collision.
Reasoning
sn1 is the standard sine output parameter of LAPACK dlaev2_. The collision comes from the normalization of short names, and the code is ordinary numerical computation.
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;
```
dismissed LLM, confidence 0.95 Scratch variable t1 in an f2c-generated LAPACK eigenvalue routine, flagged for a skeleton collision.
Reasoning
t1, t2, t3 are conventional scratch variables in the Hessenberg QR iteration of a LAPACK eigensolver. The collision is a normalization artifact of short identifiers.
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;
```
dismissed LLM, confidence 0.95 Index variable k in an f2c-generated LAPACK routine, flagged for a skeleton collision.
Reasoning
k, i__, j, m and similar are standard loop and index variables in LAPACK. Their skeleton collision is a benign artifact of the confusable-character heuristic.
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;
```
dismissed LLM, confidence 0.95 Local variable in an f2c-generated single-precision LAPACK routine, flagged because its skeleton is empty.
Reasoning
r__, cs, sn, mu and ll are conventional names in single-precision LAPACK rotation and iteration code. The empty skeleton is a normalization artifact of very 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 *,
```
dismissed LLM, confidence 0.95 Trigonometric scratch variable sinl in an f2c-generated LAPACK routine, flagged for a skeleton collision.
Reasoning
sinl, sinr and cosr are standard LAPACK scratch variables for trigonometric rotation values in the SVD routines. The skeleton collision is a benign naming artifact.
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)
{
```
dismissed LLM, confidence 0.95 Eigenvector argument vr of the f2c-generated sgeev_ routine, flagged for a skeleton collision.
Reasoning
vl and vr are the standard left and right eigenvector arguments of LAPACK sgeev_. The collision is a normalization artifact in generated numerical code.
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;
```
dismissed LLM, confidence 0.95 Local index variable ie in an f2c-generated LAPACK routine, flagged for a skeleton collision.
Reasoning
ie, il, mm and itau are ordinary LAPACK workspace and index variables. The skeleton collision is a benign artifact of short names.
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
```
dismissed LLM, confidence 0.95 Local size variable n1 in an f2c-generated LAPACK routine, flagged for a skeleton collision.
Reasoning
i__, k, n1, n2 and similar are conventional index and size variables in LAPACK divide-and-conquer code. The collision is a normalization 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];
```
dismissed LLM, confidence 0.90 Static local variable declarations in an f2c-translated LAPACK routine.
Reasoning
Identifier skeleton collision in machine-translated f2c LAPACK code; names like n1p1, psm, ctot are legitimate variable names where 1/l confusability is a naive artifact of the normalization, not obfuscation.
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 */
```
dismissed LLM, confidence 0.90 Parameter list of the slaev2_ eigen-decomposition routine in f2c-generated LAPACK.
Reasoning
Parameter names cs1/sn1 in slaev2_ collapse to a skeleton only because of digit-letter normalization; this is standard LAPACK naming in generated numerical code.
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.85 Caller frame lookup to derive a module name in numpy testing helpers.
Reasoning
sys._getframe(1) is used in numpy's testing utilities to find the caller's __file__ for naming; this is ordinary introspection. The anti-analysis label is a heuristic triggered by the file mentioning sys.exit/exec elsewhere, which is normal for a test library.
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.85 Reads the caller's frame locals and globals in a numpy testing helper.
Reasoning
Frame introspection to read caller locals and globals for assert-style evaluation is a known pattern in numpy testing utilities; no exfiltration or evasion is visible.
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 Decorator that temporarily clears the trace function while running a wrapped callable.
Reasoning
sys.settrace(None) temporarily disables tracing (e.g., coverage or debugger) around a decorated test function and restores it in finally; this is a legitimate test utility pattern for suppressing trace overhead.
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.90 Restores the previously saved trace function after the wrapped call.
Reasoning
Restoring original_trace in a finally block pairs with the earlier settrace(None), a standard save/restore idiom with no malicious indicators.
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.85 Imports a module by computed name in a numpy docs reference-checking tool.
Reasoning
A developer documentation-check tool imports a module by name taken from its own iteration over the package, then reads sys.modules. Dynamic import of a variable name is expected here and no network or payload behavior is visible.

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.0.0
git clone https://github.com/numpy/numpy numpy && cd numpy
git checkout v2.5.4
disclude scan --severity info --diff v2.5.3 .