scipy 1.18.1

Source: https://github.com/scipy/scipy
Tag scanned: v1.18.1
Compared with: v1.18.0 (0 signals introduced since)
Files: 2319 scanned, 713 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 52 warn · 148 info
Scan time: 70.8 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): the 100 most severe of 152 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:27

Signals

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

warn narrow-file-charset scipy/spatial/tests/data/pdist-jensenshannon-ml.txt:1:1

file uses only 11 distinct printable characters (".0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

0.320369972991 0.338972466 0.308199372323 0.3452431902 0.310024768313 0.357115225615 0.311131096357 0.357391534414 0.329718053755 0.347365921475 0.335272625287 0.336451560653 0.33015370606 0.369628769749 0.344499490029 0.321622508707 0.345377707016 0.321007207534 0.350728979121 0.32809430086 0.30207071308 0.29166325249

warn long-line scipy/spatial/tests/data/pdist-minkowski-3.2-ml-iris.txt:1:1

line length 178800 characters (raw pass, confidence 0.65)

   5.0817745e-01   4.4535192e-01   5.6700421e-01   1.2418578e-01   4.8927739e-01   5.0180477e-01   1.4096146e-01   8.1242502e-01   4.1586001e-01   3.2586371e-01   3.2586371e-01   5.2942799e-01   8.6137722e-01   7.7039952e-01   9.7270522e-01   4.5581864e-01   1.0000000e-01   6.3861009e-01   3.0546431e-01   3.7427929e-01

warn long-line scipy/spatial/tests/data/pdist-minkowski-3.2-ml.txt:1:1

line length 3040 characters (raw pass, confidence 0.65)

   2.0215050e+00   2.0988154e+00   1.8614681e+00   2.0510161e+00   1.9210911e+00   2.1323516e+00   1.9565454e+00   2.1029889e+00   1.9617871e+00   2.0544792e+00   2.0357408e+00   1.8811414e+00   2.0694693e+00   2.1245977e+00   2.0632165e+00   2.0452823e+00   2.0249330e+00   1.9635489e+00   2.0508580e+00   2.0838578e+00

warn long-line scipy/spatial/tests/data/pdist-minkowski-5.8-ml-iris.txt:1:1

line length 178800 characters (raw pass, confidence 0.65)

   5.0042326e-01   4.1210927e-01   5.2133179e-01   1.1269424e-01   4.2362917e-01   5.0001522e-01   1.2085435e-01   7.4262850e-01   4.0127250e-01   3.0482299e-01   3.0482299e-01   5.0436965e-01   8.0923926e-01   7.1629168e-01   9.1424701e-01   4.1317535e-01   1.0000000e-01   6.0366256e-01   3.0017653e-01   3.3813251e-01

warn long-line scipy/spatial/tests/data/pdist-seuclidean-ml-iris.txt:1:1

line length 178800 characters (raw pass, confidence 0.65)

   1.1781739e+00   8.4573383e-01   1.1040164e+00   2.6033464e-01   1.0391769e+00   6.5951091e-01   2.6643250e-01   1.6215602e+00   9.6424206e-01   5.8926015e-01   4.4417668e-01   1.2158053e+00   1.5196051e+00   1.4342986e+00   2.2147971e+00   1.0267382e+00   1.3103399e-01   1.0246015e+00   7.0646671e-01   4.6190224e-01

warn long-line scipy/spatial/tests/data/pdist-seuclidean-ml.txt:1:1

line length 3040 characters (raw pass, confidence 0.65)

   1.4330520e+01   1.4635426e+01   1.3450855e+01   1.4761140e+01   1.3508642e+01   1.5434417e+01   1.3887693e+01   1.5166776e+01   1.3966038e+01   1.4950451e+01   1.4564587e+01   1.3834201e+01   1.4347008e+01   1.5641962e+01   1.4689053e+01   1.4418720e+01   1.4545856e+01   1.4151822e+01   1.4669017e+01   1.5150750e+01

warn long-line scipy/spatial/tests/data/pdist-spearman-ml.txt:1:1

line length 3040 characters (raw pass, confidence 0.65)

   9.3540954e-01   9.7904590e-01   8.6703870e-01   1.1569997e+00   8.7174317e-01   1.0627183e+00   9.1272727e-01   1.1593999e+00   9.7573357e-01   1.0072127e+00   1.0536814e+00   9.6276028e-01   9.7700570e-01   1.1513951e+00   1.0719592e+00   9.2178818e-01   1.0004680e+00   9.3689769e-01   9.8205821e-01   1.0332673e+00

warn narrow-file-charset scipy/spatial/tests/data/random-bool-data.txt:1:1

file uses only 2 distinct printable characters ("01") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 0 1 1 0 0 1 1
1 1 1 1 1 1 1 0 0 1 1 1 0 0 0 0 1 0 1 0 1 1 1 0 1 0 1 1 1 1
0 1 0 1 1 0 0 1 1 1 1 0 1 0 0 1 1 0 1 1 1 0 1 1 0 1 1 1 0 1
```

warn narrow-file-charset scipy/spatial/tests/data/random-int-data.txt:1:1

file uses only 11 distinct printable characters ("-0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

-67 65 82 64 51 1 -12 2 -84 -52 12 82 -45 -84 -41 31 -49 36 -70 40 -74 -99 32 64 -6 43 -53 -43 43 96
-58 20 25 99 -25 78 -6 59 -23 30 36 25 -8 83 -43 -7 -8 42 -90 96 46 88 31 12 68 -21 -6 7 78 -19
-66 -51 0 13 42 -43 -30 -29 20 10 -24 -5 -42 38 -56 6 1 -80 -65 -91 89 64 -21 49 -84 41 6 -78 71 -2

warn narrow-file-charset scipy/spatial/tests/data/random-uint-data.txt:1:1

file uses only 10 distinct printable characters ("0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

52 34 59 34 64 20 89 69 26 93 95 32 17 93 77 49 51 60 51 27 60 10 61 2 16 30 41 68 65 0
43 74 11 37 32 61 72 29 47 21 7 47 68 58 22 33 29 37 14 45 71 1 67 79 69 9 6 6 95 78
86 20 68 67 43 5 77 70 96 37 79 71 35 30 22 4 56 28 33 50 97 17 85 52 21 5 57 19 35 97

warn dynamic-execution scipy/spatial/tests/test_distance.py:424:34

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

        with pytest.raises(TypeError):
            cdist(X1, X2, metric=eval(metric), **kwargs)
        with pytest.raises(TypeError):
            cdist(X1, X2, metric="test_" + metric, **kwargs)

warn dynamic-execution scipy/spatial/tests/test_distance.py:430:34

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

        with pytest.raises(TypeError):
            cdist(X1, X2, metric=eval(metric), *args)
        with pytest.raises(TypeError):
            cdist(X1, X2, metric="test_" + metric, *args)

warn dynamic-execution scipy/spatial/tests/test_distance.py:537:39

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

            y1 = cdist(X1, X2, metric=metric, **kwargs)
            y2 = cdist(X1, X2, metric=eval(metric), **kwargs)
            y3 = cdist(X1, X2, metric="test_" + metric, **kwargs)
        except Exception as e:

warn dynamic-execution scipy/spatial/tests/test_distance.py:547:38

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

            with pytest.raises(e_cls):
                cdist(X1, X2, metric=eval(metric), **kwargs)
            with pytest.raises(e_cls):
                cdist(X1, X2, metric="test_" + metric, **kwargs)

warn dynamic-execution scipy/spatial/tests/test_distance.py:714:30

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

        with pytest.raises(TypeError):
            pdist(X1, metric=eval(metric), **kwargs)
        with pytest.raises(TypeError):
            pdist(X1, metric="test_" + metric, **kwargs)

warn dynamic-execution scipy/spatial/tests/test_distance.py:720:30

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

        with pytest.raises(TypeError):
            pdist(X1, metric=eval(metric), *args)
        with pytest.raises(TypeError):
            pdist(X1, metric="test_" + metric, *args)

warn dynamic-execution scipy/spatial/tests/test_distance.py:1352:34

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

            y1 = pdist(X, metric=metric, **kwargs)
            y2 = pdist(X, metric=eval(metric), **kwargs)
            y3 = pdist(X, metric="test_" + metric, **kwargs)
        except Exception as e:

warn dynamic-execution scipy/spatial/tests/test_distance.py:1362:33

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

            with pytest.raises(e_cls):
                pdist(X, metric=eval(metric), **kwargs)
            with pytest.raises(e_cls):
                pdist(X, metric="test_" + metric, **kwargs)

warn dynamic-execution scipy/spatial/tests/test_distance.py:2021:23

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


    for m in [metric, eval(metric), "test_" + metric]:
        with pytest.raises(ValueError):
            pdist(X, m, w=w)

warn dynamic-attribute scipy/spatial/tests/test_kdtree.py:42:9

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

        test_case = type(test_name, (kls,), {'kdtree_type': tree})
        globals()[test_name] = test_case
    return kls

warn frame-introspection scipy/special/_mptestutils.py:395:17

`sys.settrace` — call-stack frame introspection (ast pass, confidence 0.70)

                    return trace
                sys.settrace(trace)
                try:
                    return func(*a, **kw)

warn frame-introspection scipy/special/_mptestutils.py:399:21

`sys.settrace` — call-stack frame introspection (ast pass, confidence 0.70)

                except TimeoutError:
                    sys.settrace(None)
                    return return_val
                finally:

warn frame-introspection scipy/special/_mptestutils.py:402:21

`sys.settrace` — call-stack frame introspection (ast pass, confidence 0.70)

                finally:
                    sys.settrace(None)
            return wrap
    return deco

warn dynamic-attribute scipy/special/_support_alternative_backends.py:165:18

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


            _f = globals()[self.name]  # Allow nested wrapping
            def f(*args, _f=_f, xp=xp, **kwargs):
                data_args = [getattr(arg, 'data', arg) for arg in args]

warn dynamic-attribute scipy/special/_support_alternative_backends.py:182:18

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


            _f = globals()[self.name]  # Allow nested wrapping
            def f(*args, _f=_f, xp=xp, **kwargs):
                # Hide dtype kwarg from map_blocks

warn dynamic-execution scipy/special/_ufunc_tools.py:159:5

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

    namespace = {"_wrapper": _wrapper}
    exec(code, namespace)
    wrapper = namespace[name]
    wrapper.__doc__ = docstring

warn identifier-confusable-collision scipy/special/cdflib.c:657:50

two identifiers collapse to visual skeleton `d|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    if ((b*z) == 0.0) { return (struct TupleDI){.d1 = w, .i1 = 1}; }

    // COMPUTATION OF THE EXPANSION
```
warn narrow-file-charset scipy/special/tests/data/boost/binomial_data_ipp/binomial_data.txt:1:1

file uses only 12 distinct printable characters (".0123456789e") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
0.15e2	0.15e2	0.1e1
0.19e2	0.15e2	0.3876e4
0.19e2	0.19e2	0.1e1
```
warn narrow-file-charset scipy/special/tests/data/boost/binomial_large_data_ipp/binomial_large_data.txt:1:1

file uses only 12 distinct printable characters (".0123456789e") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
0.174e3	0.4e1	0.36890001e8
0.174e3	0.5e1	0.1254260034e10
0.174e3	0.6e1	0.35328324291e11
```
warn narrow-file-charset scipy/special/tests/data/boost/binomial_quantile_ipp/binomial_quantile_data.txt:1:1

file uses only 11 distinct printable characters (".0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
2.0 0.12698681652545928955078125 0.12698681652545928955078125 0.0 0.28467385230321224203411154382440248724380832183117
2.0 0.12698681652545928955078125 0.135477006435394287109375 0.0 0.25727865882740919932840773421531232758964168093055
```
warn narrow-file-charset scipy/special/tests/data/boost/digamma_data_ipp/digamma_data.txt:1:1

file uses only 11 distinct printable characters (".0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
2.818432331085205078125	0.8484115700906551606307984398000472347785
4.6342258453369140625	1.421713669467331557347601964119226105014
4.783483982086181640625	1.457016504476551729585831562031964212238
```
warn narrow-file-charset scipy/special/tests/data/boost/digamma_neg_data_ipp/digamma_neg_data.txt:1:1

file uses only 12 distinct printable characters ("-.0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
-99.7181549072265625	2.03892909952497242038694056382195623059
-99.5216522216796875	4.3913617771941913117971009646096341326
-98.80979156494140625	-0.01795976054399933340057713377738267488686
```
warn narrow-file-charset scipy/special/tests/data/boost/digamma_root_data_ipp/digamma_root_data.txt:1:1

file uses only 12 distinct printable characters ("-.0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
1.39999997615814208984375	-0.06138456903152256550686860248931989075643
1.4005000591278076171875	-0.06087192929516339380130503872301167293378
1.40100002288818359375	-0.06035965880979232302674791723368356347747
```
warn narrow-file-charset scipy/special/tests/data/boost/erf_inv_data_ipp/erf_inv_data.txt:1:1

file uses only 12 distinct printable characters ("-.0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
-0.990433037281036376953125	-1.832184533179510927322805923563700329767
-0.936334311962127685546875	-1.311339282092737086640055105484822812599
-0.931107819080352783203125	-1.286316461685184857889337272829270644576
```
warn narrow-file-charset scipy/special/tests/data/boost/erfc_inv_data_ipp/erfc_inv_data.txt:1:1

file uses only 12 distinct printable characters ("-.0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
0.00956696830689907073974609375	1.832184391051582711731256541599359331735
0.063665688037872314453125	1.311339282092737086640055105484822812599
0.068892158567905426025390625	1.286316565305373898738127895195338854718
```
warn narrow-file-charset scipy/special/tests/data/boost/expinti_data_double_ipp/expinti_data_double.txt:1:1

file uses only 12 distinct printable characters (".0123456789e") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
102.87009429931640625	4654899469800805764672952463660041015404000.0
119.09970855712890625	0.4488787864805080932333174640972770490538e50
120.6676483154296875	0.2124946028694675872596376925084081671409e51
```
warn narrow-file-charset scipy/special/tests/data/boost/expinti_data_long_ipp/expinti_data_long.txt:1:1

file uses only 12 distinct printable characters (".0123456789e") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
850.51361083984375 0.27809823533792637952061836944224670902e367
1136.15478515625 0.2348005093803919554840423708437417479629e491
1163.7506103515625 0.2213003663371766101124862788858798209669e503
```

warn narrow-file-charset scipy/special/tests/data/boost/gamma_inv_big_data_ipp/gamma_inv_big_data.txt:1:1

file uses only 11 distinct printable characters (".0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

464.56927490234375	0.12698681652545928955078125	440.0905015614498663381793089656310373835539712118699915057655756381750702144551901256933419148259778	489.2489328115381710888005650788332818303123263238882523231037266766796974176786885492715539575179927

warn narrow-file-charset scipy/special/tests/data/boost/gamma_inv_data_ipp/gamma_inv_data.txt:1:1

file uses only 11 distinct printable characters (".0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

9.754039764404296875	0.12698681652545928955078125	6.349849983781954486964960115093039567468747967664820851534065876063014180392060424555352423162443804	13.35954665556050630769710564071384909890705633863167415813992116806093647564994418684947673739937248

warn narrow-file-charset scipy/special/tests/data/boost/igamma_inva_data_ipp/igamma_inva_data.txt:1:1

file uses only 11 distinct printable characters (".0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

0.11342023313045501708984375	0.097540400922298431396484375	1.035869900800721563193351335409353423054156223778352824799732510014114331303190861923913851617789576	0.05862165929221091309602935851268320728966552926925608108837955463403857541085640683871851098187935567

warn narrow-file-charset scipy/special/tests/data/boost/legendre_p_ipp/legendre_p.txt:1:1

file uses only 12 distinct printable characters ("-.0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

3.0 -0.804919183254241943359375 -0.09637879251279735399302410605920296560178428535437 -0.84585603807674271376114723023136351467791030262194
3.0 -0.74602639675140380859375 0.081027074619746344180737168075984167003866787126753 -0.80282652754865351221792807765781454966620965987346

warn narrow-file-charset scipy/special/tests/data/boost/negative_binomial_quantile_ipp/negative_binomial_quantile_data.txt:1:1

file uses only 11 distinct printable characters (".0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
4.285762786865234375	0.12698681652545928955078125	0.097540400922298431396484375	11.568381290037563253305975817351444024377036234904	49.67581419477884086070549390307050513757197652133
```

warn narrow-file-charset scipy/special/tests/data/boost/poisson_quantile_ipp/poisson_quantile_data.txt:1:1

file uses only 11 distinct printable characters (".0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)

2.539736270904541015625	0.097540400922298431396484375	0.1236392659323415267286721455855935332272165776019	4.1794244675777288954971650240102219690023733491107
2.539736270904541015625	0.12698681652545928955078125	0.29692152360861802647109703200927257466043783201072	3.8759279753758017243263560996428606489658831749751

warn narrow-file-charset scipy/special/tests/data/boost/zeta_1_below_data_ipp/zeta_1_below_data.txt:1:1

file uses only 12 distinct printable characters ("-.0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
0.02141654491424560546875	-0.5201506602793944998316548018699690797681
0.50472259521484375	-1.479059796502255763615575236860218694317
0.753675937652587890625	-3.500701844470537839375475836745309608254
```
warn narrow-file-charset scipy/special/tests/data/boost/zeta_1_up_data_ipp/zeta_1_up_data.txt:1:1

file uses only 11 distinct printable characters (".0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
1.00000011920928955078125	8388608.57721567358185799990090564625463
1.0000002384185791015625	4194304.577215682262183001486952251646755
1.000000476837158203125	2097152.577215699622832591533990692770612
```
warn narrow-file-charset scipy/special/tests/data/boost/zeta_data_ipp/zeta_data.txt:1:1

file uses only 11 distinct printable characters (".0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
1.16628754138946533203125	6.602868183069916948720755731837247651904
1.28222560882568359375	4.140637712279411074557164685415721499333
1.7022221088409423828125	2.049914055577335303673424130546639695977
```

warn dynamic-execution scipy/special/tests/test_orthogonal.py:282:21

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

            for pstr in poly:
                p = eval(pstr)
                assert_allclose(p(0.315), np.poly1d(p.coef)(0.315),
                                atol=1.5e-7, rtol=0, err_msg=pstr)

warn dynamic-execution scipy/stats/_distn_infrastructure.py:748:9

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

        ns = {}
        exec(self._parse_arg_template, ns)
        # NB: attach to the instance, not class
        for name in ['_parse_args', '_parse_args_stats', '_parse_args_rvs']:

warn decoder-import-with-exec scipy/stats/tests/test_continuous.py:87:15

file imports decoder module(s) pickle and calls `exec`/`eval`/`compile` — multi-stage payload shape (ast pass, confidence 0.80)

        right_comparison = '<=' if inclusive_b else '<'
        ref = eval(f'(a {left_comparison} x) & (x {right_comparison} b)')
        assert_equal(res, ref)

warn dynamic-execution scipy/stats/tests/test_continuous.py:2138:20

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

        from scipy.stats._new_distributions import Uniform # noqa: F401
        new_dist = eval(repr(dist))
        # A basic check that the distributions are the same
        sample1 = dist.sample(shape=10, rng=1234)

warn dynamic-import tools/wheels/cibw_before_build.sh:20:5

`source` called with a dynamic path — sourcing a variable script path (ast pass, confidence 0.75)
```
  if [[ $INSTALL_GFORTRAN == "true" ]]; then
    source $PROJECT_DIR/tools/wheels/gfortran_macos.sh
  fi
fi
```

warn dynamic-execution tools/write_release_and_log.py:78:5

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

    tmp_target = Path(filename + '.txt')
    os.system(f'cp {source} {tmp_target}')

    with open(str(tmp_target), 'a') as ftarget:

info ~~warn~~ → info by review narrow-file-charset benchmarks/benchmarks/cutest/dfo.txt:1:1

file uses only 10 distinct printable characters ("0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
    1    9   45    0
    1    9   45    1
    2    7   35    0
```
dismissed LLM, confidence 0.90 A numeric data file in the CUTEst benchmarks that uses only digits and whitespace.
Reasoning
The file is a plain numeric data table of digits, spaces and newlines. A narrow character set is expected for numeric benchmark data and shows no encoded payload or obfuscation.
info ~~critical~~ → info by review dynamic-execution benchmarks/benchmarks/stats.py:557:22

`eval` called on a constructed string (ast pass, confidence 0.80)
```
              shape1_fixed, shape2_fixed, shape3_fixed):
        self.distn = eval("stats." + dist_name)

        # default `loc` and `scale` are .834 and 4.342, and shapes are from
```
likely benign LLM, confidence 0.80 A benchmark class resolves a scipy.stats distribution by evaluating 'stats.' plus a name.
Reasoning
eval builds the name by prefixing 'stats.' to dist_name, which comes from scipy's own distribution-name arguments. This is a common lazy-lookup idiom in a benchmark helper, not attacker-controlled input, though eval on a constructed string is a poor practice.
info ~~critical~~ → info by review dynamic-import doc/source/conf.py:450:9

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
    try:
        __import__(name)
        extensions.append(name)
        break
```
dismissed LLM, confidence 0.90 A Sphinx configuration loop that imports extension modules by name.
Reasoning
This is a standard Sphinx conf.py pattern: it tries to import each configured extension name inside a try block and records the successes. The names come from the project's own configuration list.
info ~~warn~~ → info by review unicode-mixed-script doc/source/release/1.8.0-notes.rst:782:122

identifier `iπ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)
```
* `#14706 <https://github.com/scipy/scipy/pull/14706>`__: BUG: Fix hyp2f1 to return correct values in regions near exp(±iπ/3).
* `#14707 <https://github.com/scipy/scipy/pull/14707>`__: Update constants.py
* `#14708 <https://github.com/scipy/scipy/pull/14708>`__: BENCH: shorten svds benchmark that is timing out in CI
```
dismissed LLM, confidence 0.95 A release-notes line mentions exp(±iπ/3) with a Greek pi in a math expression.
Reasoning
The Greek letter pi appears inside a mathematical expression in release-note prose, as in exp(±iπ/3). It is not an identifier used in code, so the mixed-script flag is a false positive.
info ~~critical~~ → info by review dynamic-import doc/source/scipyoptdoc.py:52:5

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
    module_name = '.'.join(parts[:-1])
    __import__(module_name)
    obj = getattr(sys.modules[module_name], parts[-1])
    return obj
```
likely benign LLM, confidence 0.85 A documentation helper that imports a module from a dotted path and fetches an attribute.
Reasoning
This is a Sphinx extension helper that resolves a dotted object path by importing the module and fetching the attribute. The module name is derived from documentation directive text, which is a standard and benign documentation-tooling pattern.

info unicode-mixed-script doc/source/tutorial/examples/fft_remove_trend.py:33:44

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

ax1.set(title="Magnitude Spectrum", xticklabels=[])
ax2.set_xlabel(rf"Frequency $f$ in hertz ($Δf={f[1]:g}\,$Hz, $f_S={1e-3/T:g}\,$kHz)")
for ax_ in (ax0, ax1, ax2):
    ax_.grid(True)

info ~~warn~~ → info by review unicode-mixed-script doc/source/tutorial/fft.rst:107:61

identifier `jπ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)
```
.. A comment for the sake of completeness: Proving that `FF := conj(F) @ F` = N I holds
   amounts to noting that each entry FF[p, q] = sum_k( exp(2jπ k (p-q) / N) ) is a
   finite geometric series, which is straightforward to evaluate.
```
dismissed LLM, confidence 0.95 A tutorial's FFT math text uses a Greek pi in a formula.
Reasoning
The Greek pi sits in a mathematical formula inside reStructuredText prose (exp(2jπ k ...)). This is ordinary math notation in documentation, not an identifier used for code hiding.

info long-line doc/source/tutorial/signal.rst:207:1

line length 975 characters (raw pass, confidence 0.50)

    \begin{eqnarray*} y\left[0\right] & = & x\left[0\right]h\left[0\right]\\ y\left[1\right] & = & x\left[0\right]h\left[1\right]+x\left[1\right]h\left[0\right]\\ y\left[2\right] & = & x\left[0\right]h\left[2\right]+x\left[1\right]h\left[1\right]+x\left[2\right]h\left[0\right]\\ \vdots & \vdots & \vdots\\ y\left[M\righ

info long-line doc/source/tutorial/signal.rst:287:1

line length 1146 characters (raw pass, confidence 0.50)

    \begin{eqnarray*} w\left[-K\right] & = & y\left[K\right]x\left[0\right]\\ w\left[-K+1\right] & = & y\left[K-1\right]x\left[0\right]+y\left[K\right]x\left[1\right]\\ \vdots & \vdots & \vdots\\ w\left[M-K\right] & = & y\left[K-M\right]x\left[0\right]+y\left[K-M+1\right]x\left[1\right]+\cdots+y\left[K\right]x\left[M\r

info long-line doc/source/tutorial/stats/continuous_loguniform.rst:20:1

line length 702 characters (raw pass, confidence 0.50)

    \begin{eqnarray*} d & = & \log\left(a/b\right)\\ \mu & = & \frac{a-b}{d}\\ \mu_{2} & = & \mu\frac{a+b}{2}-\mu^{2}=\frac{\left(a-b\right)\left[a\left(d-2\right)+b\left(d+2\right)\right]}{2d^{2}}\\ \gamma_{1} & = & \frac{\sqrt{2}\left[12d\left(a-b\right)^{2}+d^{2}\left(a^{2}\left(2d-9\right)+2abd+b^{2}\left(2d+9\righ

info long-line doc/source/tutorial/stats/continuous_tukeylambda.rst:17:1

line length 828 characters (raw pass, confidence 0.50)

    \begin{eqnarray*} \mu & = & 0\\ \mu_{2} & = & \int_{0}^{1}G^{2}\left(p;\lambda\right)dp\\  & = & \frac{2\Gamma\left(\lambda+\frac{3}{2}\right)-\lambda4^{-\lambda}\sqrt{\pi}\Gamma\left(\lambda\right)\left(1-2\lambda\right)}{\lambda^{2}\left(1+2\lambda\right)\Gamma\left(\lambda+\frac{3}{2}\right)}\\ \gamma_{1} & = &

info long-line doc/source/tutorial/stats/discrete_boltzmann.rst:10:1

line length 534 characters (raw pass, confidence 0.50)

    \begin{eqnarray*} p\left(k;N,\lambda\right) & = & \frac{1-e^{-\lambda}}{1-e^{-\lambda N}}\exp\left(-\lambda k\right)\quad k\in\left\{ 0,1,\ldots,N-1\right\} \\ F\left(x;N,\lambda\right) & = & \left\{ \begin{array}{cc} 0 & x<0\\ \frac{1-\exp\left[-\lambda\left(\left\lfloor x\right\rfloor +1\right)\right]}{1-\exp\lef

info long-line doc/source/tutorial/stats/discrete_boltzmann.rst:17:1

line length 547 characters (raw pass, confidence 0.50)

    \begin{eqnarray*} \mu & = & \frac{z}{1-z}-\frac{Nz^{N}}{1-z^{N}}\\ \mu_{2} & = & \frac{z}{\left(1-z\right)^{2}}-\frac{N^{2}z^{N}}{\left(1-z^{N}\right)^{2}}\\ \gamma_{1} & = & \frac{z\left(1+z\right)\left(\frac{1-z^{N}}{1-z}\right)^{3}-N^{3}z^{N}\left(1+z^{N}\right)}{\left[z\left(\frac{1-z^{N}}{1-z}\right)^{2}-N^{2}

info long-line doc/source/tutorial/stats/discrete_dlaplace.rst:12:1

line length 657 characters (raw pass, confidence 0.50)

    \begin{eqnarray*} p\left(k\right) & = & \tanh\left(\frac{a}{2}\right)e^{-a\left|k\right|},\\ F\left(x\right) & = & \left\{ \begin{array}{cc} \frac{e^{a\left(\left\lfloor x\right\rfloor +1\right)}}{e^{a}+1} & \left\lfloor x\right\rfloor <0,\\ 1-\frac{e^{-a\left\lfloor x\right\rfloor }}{e^{a}+1} & \left\lfloor x\righ

info long-line doc/source/tutorial/stats/discrete_hypergeom.rst:12:1

line length 833 characters (raw pass, confidence 0.50)

    \begin{eqnarray*} p\left(k;N,n,M\right) & = & \frac{\left(\begin{array}{c} n\\ k\end{array}\right)\left(\begin{array}{c} M-n\\ N-k\end{array}\right)}{\left(\begin{array}{c} M\\ N\end{array}\right)}\quad N-\left(M-n\right)\leq k\leq\min\left(n,N\right)\\ F\left(x;N,n,M\right) & = & \sum_{k=0}^{\left\lfloor x\right\r

info long-line doc/source/tutorial/stats/discrete_nbinom.rst:14:1

line length 569 characters (raw pass, confidence 0.50)

    \begin{eqnarray*} p\left(k;n,p\right) & = & \left(\begin{array}{c} k+n-1\\ n-1\end{array}\right)p^{n}\left(1-p\right)^{k}\quad k\geq0\\ F\left(x;n,p\right) & = & \sum_{i=0}^{\left\lfloor x\right\rfloor }\left(\begin{array}{c} i+n-1\\ i\end{array}\right)p^{n}\left(1-p\right)^{i}\quad x\geq0\\  & = & I_{p}\left(n,\le

info long-line doc/source/tutorial/stats/discrete_zipf.rst:26:1

line length 668 characters (raw pass, confidence 0.50)

    \begin{eqnarray*} F\left(x;\alpha\right) & = & \frac{1}{\zeta\left(\alpha\right)}\sum_{k=1}^{\left\lfloor x\right\rfloor }\frac{1}{k^{\alpha}}\\ \mu & = & \frac{\zeta_{1}}{\zeta_{0}}\quad\alpha>2\\ \mu_{2} & = & \frac{\zeta_{2}\zeta_{0}-\zeta_{1}^{2}}{\zeta_{0}^{2}}\quad\alpha>3\\ \gamma_{1} & = & \frac{\zeta_{3}\z

info long-line doc/source/tutorial/stats/rv_infrastructure.md:864:1

line length 585 characters (raw pass, confidence 0.50)

But the new infrastructure is much faster when arrays are involved. This is because the underlying integrator ([`scipy.integrate.tanhsinh`](https://scipy.github.io/devdocs/reference/generated/scipy.integrate.tanhsinh.html#scipy.integrate.tanhsinh)) and root finder ([`scipy.optimize.elementwise.find_root`](https://scipy

info ~~warn~~ → info by review dynamic-attribute scipy/__init__.py:140:20

reach-by-name through `globals` (ast pass, confidence 0.60)
```
        try:
            return globals()[name]
        except KeyError:
            raise AttributeError(
```
dismissed LLM, confidence 0.90 The package's module __getattr__ resolves lazily loaded names through globals().
Reasoning
This is the module-level __getattr__ fallback for lazy-loaded submodules. It looks up names in globals() and raises AttributeError on a miss, which is the standard Python lazy-attribute idiom.
info ~~critical~~ → info by review frame-introspection scipy/_build_utils/tempita/_tempita.py:129: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 The Tempita template engine reads the caller's frame to obtain its namespace.
Reasoning
Tempita uses sys._getframe to find the calling template namespace when rendering. Frame introspection is a legitimate feature of a template engine, and the co-occurrence with exit/exec/eval is expected in that code, not an anti-analysis shape.
info ~~warn~~ → info by review dynamic-execution scipy/_build_utils/tempita/_tempita.py:308: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(
```
likely benign LLM, confidence 0.80 The Tempita engine evaluates template expression code in a namespace.
Reasoning
Evaluating template expressions is the core function of the Tempita template engine. The code comes from template sources the build system controls, so this is expected behaviour, not a hidden dropper.
info ~~warn~~ → info by review dynamic-execution scipy/_build_utils/tempita/_tempita.py:324: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.80 The Tempita engine executes template statement code in a namespace.
Reasoning
Executing template statements is also a core Tempita feature, and it runs within the template's own namespace. Its presence in a template engine is expected.
info ~~warn~~ → info by review dynamic-execution scipy/_build_utils/tempita/_tempita.py:1075: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.75 The Tempita command-line tool evaluates variable values supplied as arguments.
Reasoning
This is the command-line handler for Tempita, which evaluates values passed as template variable arguments. It is a dev-tooling convenience that runs on developer-supplied input at build time, so it is a mild risk rather than a sign of malice.
info ~~warn~~ → info by review dynamic-execution scipy/_lib/_bunch.py:160:5

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
                 '__name__': f'namedtuple_{typename}'}
    exec(s, namespace)
    __new__ = namespace['__new__']
    __new__.__doc__ = f'Create new instance of {typename}({full_list})'
```
likely benign LLM, confidence 0.85 A bunch/namedtuple helper that generates __new__ via exec from a code template.
Reasoning
This is the standard exec-based namedtuple construction, which builds __new__ from a generated template string. The typename and field names come from the code's own definitions, and this is a well-known stdlib pattern.
info identifier-low-length scipy/cluster/hierarchy/tests/hierarchy_test_data.py:1:1

91 of 135 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)
info ~~warn~~ → info by review decoder-decompress-payload scipy/datasets/_fetchers.py:220:17

file imports decoder module(s) pickle, bz2 and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
        rawdata = f.read()
    face_data = bz2.decompress(rawdata)
    face = frombuffer(face_data, dtype='uint8').reshape((768, 1024, 3))
    if gray is True:
```
likely benign LLM, confidence 0.95 Decompresses a bz2-packed image dataset read from a local file in scipy's datasets fetcher.
Reasoning
bz2.decompress of a bundled data file (raman/face dataset) read from disk is a normal way to load packaged scientific data; no execution or dropper behavior is visible.
info ~~warn~~ → info by review identifier-confusable-collision scipy/integrate/__quadpack.c:405:56

two identifiers collapse to visual skeleton `b|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    double a1, a2, abseps, area, area1, area12, area2, b1, b2, boun, correc, defabs;
    double defab1, defab2, dres, erlarg, erlast, errbnd, errmax, error1, error2;
    double error12, errsum, ertest, resabs, reseps, small;
```
dismissed LLM, confidence 0.97 Declarations of numerical quadrature local variables flagged by a visual-skeleton heuristic.
Reasoning
Identifier names like b1, b2, boun are ordinary Fortran-derived numerical variable names; the 'collision' is an artifact of the confusable-character heuristic on the letter l/1/I skeleton and not an attack.
info ~~warn~~ → info by review identifier-confusable-collision scipy/integrate/__quadpack.c:2148:43

two identifiers collapse to visual skeleton `d|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    int ktmin, l, last, ll, iter, momcom, nev, nres, numrl2;
    double abseps, correc, cycle, c1, c2, dl, drl, ep, eps, epsa;
    double errsum, fact, p1, reseps;
    double psum[52], res3la[3] = {0.0};
```
dismissed LLM, confidence 0.97 Local numeric variable declarations in translated QUADPACK code flagged by identifier-skeleton heuristic.
Reasoning
Standard C local variable declarations in translated QUADPACK code; the confusable-skeleton match is a false positive from the heuristic.
info ~~warn~~ → info by review macro-keyword-override scipy/integrate/__quadpack.h:7:1

`#define F_INT int` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)
```
#define F_INT int

#define PYERR(errobj,message) {PyErr_SetString(errobj,message); goto fail;}
```
likely benign LLM, confidence 0.90 Header macro alias mapping F_INT to the C int type for Fortran interop.
Reasoning
Defining a type alias macro F_INT as int is a common portability idiom in Fortran-to-C bindings (for Fortran integer width); it does not hide malicious behavior.
info identifier-low-length scipy/integrate/_ivp/dop853_coefficients.py:1:1

mean non-conventional identifier length 1.68 over 291 names (token pass, confidence 0.50)
info identifier-low-length scipy/integrate/_lebedev.py:1:1

10884 of 18566 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)
info ~~warn~~ → info by review identifier-confusable-collision scipy/interpolate/src/dfitpack.c:74:128

two identifiers collapse to visual skeleton `co` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
                     double *av1, double *av2, double *bu, double *bv, double *a0, double *a1, double *b0, double *b1, double *c0,
                     double *c1, double *cosi, int *nru, int *nrv);
```
dismissed LLM, confidence 0.97 Function prototype parameter list in FITPACK C code flagged by identifier-skeleton heuristic.
Reasoning
Function prototype parameter names (a0, a1, c0, c1) in generated FITPACK code; heuristic collision only.
info ~~warn~~ → info by review identifier-confusable-collision scipy/interpolate/src/dfitpack.c:195:49

two identifiers collapse to visual skeleton `i|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    double per, tol, dist;
    int i, ia1, ia2, ib, ifp, ig1, ig2, iq, iz, i1, i2, j1, j2, k1, k2, lwest;
    int maxit, m1, nmin, ncc, j;
```
dismissed LLM, confidence 0.97 Integer local variable declarations in FITPACK C code.
Reasoning
Ordinary integer local variable declarations in numerical code; confusable-skeleton false positive.
info ~~warn~~ → info by review identifier-confusable-collision scipy/interpolate/src/dfitpack.c:469:22

two identifiers collapse to visual skeleton `||` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
            int l0 = l;
            for (int l1 = j; l1 <= k; l1++) {
                l0++;
                store = store - c[l0 - 1] * b[(l - 1) + (l1 - 1) * nest];
```
dismissed LLM, confidence 0.97 Array indexing arithmetic in FITPACK C numerical code.
Reasoning
Normal array indexing arithmetic in numerical routine; the flagged token is a heuristic artifact.
info ~~warn~~ → info by review identifier-confusable-collision scipy/interpolate/src/dfitpack.c:658:16

two identifiers collapse to visual skeleton `t|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
        l++;
        double tl = t[l - 1];
        do {
            i++;
```
dismissed LLM, confidence 0.97 Local variable assignment from array in FITPACK C code.
Reasoning
Ordinary local variable and array access in spline numerical code; heuristic false positive.
info ~~warn~~ → info by review identifier-confusable-collision scipy/interpolate/src/dfitpack.c:2263:84

two identifiers collapse to visual skeleton `n|` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    int i, ibandx, ibandy, ic, iq, irot, it, iz, i1, i2, j, k, k1, k2, l, l1, l2;
    int ncof, nk1x, nk1y, nrold, nroldx, nroldy, number, numx, numx1, numy, numy1, n1;
    double arg, cos, fac, pinv, piv, sin, term;
    double h[7];
```
dismissed LLM, confidence 0.97 Local variable declarations in FITPACK C code.
Reasoning
Standard local variable declarations in numerical C code; confusable-skeleton false positive.
info ~~warn~~ → info by review identifier-confusable-collision scipy/interpolate/src/dfitpack.c:3566:14

two identifiers collapse to visual skeleton `|co` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    int i, id0, iop0, iop1, i1, j, l, lau, lav1, lav2, la0, la1, lbu, lbv, lb0;
    int lb1, lc0, lc1, lcs, lq, lri, lsu, lsv, l1, l2, mm, mvnu, number, id1;
    int nr[6];
    double delta[6], drr[6], sum[6], a[6 * 6], g[6];
```
dismissed LLM, confidence 0.97 Local variable declarations in FITPACK C code.
Reasoning
Standard local variable declarations in numerical C code; confusable-skeleton false positive.
info ~~warn~~ → info by review decoder-decompress-payload scipy/io/_idl.py:812:26

file imports decoder module(s) zlib and calls `.decompress()` — embedded payload decompressed at runtime (ast pass, confidence 0.75)
```
            # Decompress record
            rec_string = zlib.decompress(f.read(nextrec-pos))

            # Find new position of next record
```
likely benign LLM, confidence 0.95 Decompresses IDL save file records using zlib as part of the readsav file format parser.
Reasoning
zlib.decompress of IDL save-file records is the documented format parsing for scipy.io.readsav; reads from a user-supplied data file, not an embedded executable payload.
info ~~warn~~ → info by review payload-bytes-literal scipy/io/tests/test_netcdf.py:203:17

concatenated bytes literal contains 111 `\xNN` escapes (97% of content) — binary payload shape (ast pass, confidence 0.85)
```
    expected = (b'CDF\x01'
                b'\x00\x00\x00\x00'
                b'\x00\x00\x00\x0a'
```
likely benign LLM, confidence 0.97 Test fixture constructing a NetCDF binary header as a bytes literal.
Reasoning
A test file building a NetCDF binary header as a bytes literal with \x escapes is the expected way to write binary fixtures; no malicious behavior.
info identifier-low-length scipy/linalg/_linalg_pythran.py:1:1

22 of 46 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)
info ~~warn~~ → info by review dynamic-attribute scipy/ndimage/_support_alternative_backends.py:122:5

reach-by-name through `vars` (ast pass, confidence 0.60)
```
    # add the decorated function to the namespace, to be imported in __init__.py
    vars()[func_name] = f
```
likely benign LLM, confidence 0.90 Registers decorated functions into module namespace via vars().
Reasoning
Populating module namespace via vars() when decorating functions for later import in __init__.py is a common, legitimate scipy pattern for backend dispatch.
info ~~warn~~ → info by review identifier-confusable-collision scipy/ndimage/src/ni_filters.c:43:22

two identifiers collapse to visual skeleton `||` (0/O/o and 1/l/I are confusable) (token pass, confidence 0.80)
```
    int symmetric = 0, more;
    npy_intp ii, jj, ll, lines, length, size1, size2, filter_size;
    double *ibuffer = NULL, *obuffer = NULL;
    npy_double *fw;
```
dismissed LLM, confidence 0.90 Short C local variable names flagged as visually confusable.
Reasoning
Identifiers 'll', 'ii', 'lines' etc. differ in meaning; the confusable collision is a false positive from the skeleton matcher on ordinary short C variable names in numerical code.
info ~~warn~~ → info by review narrow-file-charset scipy/ndimage/tests/data/label_results.txt:1:1

file uses only 10 distinct printable characters ("0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
1 1 1 1 1 1 1
1 1 1 1 1 1 1
1 1 1 1 1 1 1
```
dismissed LLM, confidence 0.95 Test data file containing label arrays of digits and spaces.
Reasoning
A plain text data file of labeled integer arrays used as test expectations; digit-only content is natural for this data, not obfuscation.
info whitespace-anomaly scipy/ndimage/tests/test_interpolation.py:6:1

file mixes tab and space indentation (1 tab-indented and 1252 space-indented lines) (raw pass, confidence 0.40)
```
from scipy._lib._array_api import (
    _asarray, assert_array_almost_equal,
    is_jax, np_compat,
    xp_assert_equal, xp_assert_close,
```
info ~~warn~~ → info by review dynamic-execution scipy/optimize/_nonlin.py:1642:5

`exec` called on a non-literal expression (ast pass, confidence 0.70)
```
    ns.update(globals())
    exec(wrapper, ns)
    func = ns[name]
    func.__doc__ = jac.__doc__
```
likely benign LLM, confidence 0.88 Generates a wrapper function via exec for the nonlinear solver's signature.
Reasoning
exec runs a generated wrapper source in a namespace to create a function with specific signature; this is a known code-generation pattern in scipy nonlin solvers, though exec is inherently notable. The wrapper is built internally from known templates, not external input.
info ~~critical~~ → info by review dynamic-import scipy/optimize/_optimize.py:4155:13

`__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
            mod_name = ".".join(parts[:-1])
            __import__(mod_name)
            obj = getattr(sys.modules[mod_name], parts[-1])
```
likely benign LLM, confidence 0.85 Dynamically imports a module path derived from a qualified name.
Reasoning
__import__ of a module name derived from splitting a qualified function name for resolving a reference (likely docstring/ lookup helper). The module name comes from internal string parsing, not untrusted input; critical severity is overstated.
info ~~warn~~ → info by review dynamic-attribute scipy/optimize/_root_scalar.py:241:13

reach-by-name through `locals.get` (ast pass, confidence 0.60)
```
    for k in ['xtol', 'rtol', 'maxiter']:
        v = locals().get(k)
        if v is not None:
            kwargs[k] = v
```
likely benign LLM, confidence 0.90 Collects named local variables into kwargs via locals().get.
Reasoning
locals().get over a fixed list of keyword names to collect optional arguments is an ordinary idiom for passing parameters through.
info ~~warn~~ → info by review dynamic-execution scipy/optimize/tests/test_constraints.py:183:23

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
            bounds = Bounds(*args)
            bounds2 = eval(repr(Bounds(*args)))
            assert_array_equal(bounds.lb, bounds2.lb)
            assert_array_equal(bounds.ub, bounds2.ub)
```
likely benign LLM, confidence 0.92 Test evaluates repr of a Bounds object to verify round-trip.
Reasoning
eval of repr of a Bounds object in a test checks round-tripping; the input is a locally constructed object, not external data.
info ~~warn~~ → info by review dynamic-attribute scipy/signal/_filter_design.py:6096:14

reach-by-name through `vars` (ast pass, confidence 0.60)
```
for name in _names:
    window = vars()[name]
    window.__doc__ = doccer.docformat(window.__doc__, _xp_device_snippet)
```
likely benign LLM, confidence 0.90 Updates docstrings of window functions looked up by name via vars().
Reasoning
Using vars() to fetch window function names from a fixed list to update docstrings is a legitimate module-level pattern.

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1125:35

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

    # We have that:
    #     q(n) = 1/π ∫W(ω)cos(nω)dω (over 0->π)
    # Using our normalization ω=πf and with a constant weight W over each
    # interval f1->f2 we get:

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1125:39

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

    # We have that:
    #     q(n) = 1/π ∫W(ω)cos(nω)dω (over 0->π)
    # Using our normalization ω=πf and with a constant weight W over each
    # interval f1->f2 we get:

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1126:34

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

    #     q(n) = 1/π ∫W(ω)cos(nω)dω (over 0->π)
    # Using our normalization ω=πf and with a constant weight W over each
    # interval f1->f2 we get:
    #     q(n) = W∫cos(πnf)df (0->1) = Wf sin(πnf)/πnf

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1128:26

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

    # interval f1->f2 we get:
    #     q(n) = W∫cos(πnf)df (0->1) = Wf sin(πnf)/πnf
    # integrated over each f1->f2 pair (i.e., value at f2 - value at f1).
    n = np.arange(numtaps)[:, np.newaxis, np.newaxis]

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1128:50

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

    # interval f1->f2 we get:
    #     q(n) = W∫cos(πnf)df (0->1) = Wf sin(πnf)/πnf
    # integrated over each f1->f2 pair (i.e., value at f2 - value at f1).
    n = np.arange(numtaps)[:, np.newaxis, np.newaxis]

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1128:56

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

    # interval f1->f2 we get:
    #     q(n) = W∫cos(πnf)df (0->1) = Wf sin(πnf)/πnf
    # integrated over each f1->f2 pair (i.e., value at f2 - value at f1).
    n = np.arange(numtaps)[:, np.newaxis, np.newaxis]

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1139:41

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

    # Now for b(n) we have that:
    #     b(n) = 1/π ∫ W(ω)D(ω)cos(nω)dω (over 0->π)
    # Using our normalization ω=πf and with a constant weight W over each
    # interval and a linear term for D(ω) we get (over each f1->f2 interval):

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1139:45

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

    # Now for b(n) we have that:
    #     b(n) = 1/π ∫ W(ω)D(ω)cos(nω)dω (over 0->π)
    # Using our normalization ω=πf and with a constant weight W over each
    # interval and a linear term for D(ω) we get (over each f1->f2 interval):

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1140:34

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

    #     b(n) = 1/π ∫ W(ω)D(ω)cos(nω)dω (over 0->π)
    # Using our normalization ω=πf and with a constant weight W over each
    # interval and a linear term for D(ω) we get (over each f1->f2 interval):
    #     b(n) = W ∫ (mf+c)cos(πnf)df

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1142:34

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

    # interval and a linear term for D(ω) we get (over each f1->f2 interval):
    #     b(n) = W ∫ (mf+c)cos(πnf)df
    #          = f(mf+c)sin(πnf)/πnf + mf**2 cos(nπf)/(πnf)**2
    # integrated over each f1->f2 pair (i.e., value at f2 - value at f1).

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1143:29

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

    #     b(n) = W ∫ (mf+c)cos(πnf)df
    #          = f(mf+c)sin(πnf)/πnf + mf**2 cos(nπf)/(πnf)**2
    # integrated over each f1->f2 pair (i.e., value at f2 - value at f1).
    n = n[:M + 1]  # only need this many coefficients here

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1143:35

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

    #     b(n) = W ∫ (mf+c)cos(πnf)df
    #          = f(mf+c)sin(πnf)/πnf + mf**2 cos(nπf)/(πnf)**2
    # integrated over each f1->f2 pair (i.e., value at f2 - value at f1).
    n = n[:M + 1]  # only need this many coefficients here

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1143:52

identifier `nπf` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

    #     b(n) = W ∫ (mf+c)cos(πnf)df
    #          = f(mf+c)sin(πnf)/πnf + mf**2 cos(nπf)/(πnf)**2
    # integrated over each f1->f2 pair (i.e., value at f2 - value at f1).
    n = n[:M + 1]  # only need this many coefficients here

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1143:59

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

    #     b(n) = W ∫ (mf+c)cos(πnf)df
    #          = f(mf+c)sin(πnf)/πnf + mf**2 cos(nπf)/(πnf)**2
    # integrated over each f1->f2 pair (i.e., value at f2 - value at f1).
    n = n[:M + 1]  # only need this many coefficients here

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1150:42

identifier `nπf` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)

    b = bands * (m*bands + c) * np.sinc(bands * n)
    # Use L'Hospital's rule here for cos(nπf)/(πnf)**2 @ n=0
    b[0] -= m * bands * bands / 2.
    b[1:] += m * np.cos(n[1:] * np.pi * bands) / (np.pi * n[1:]) ** 2

info unicode-mixed-script scipy/signal/_fir_filter_design.py:1150:49

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

    b = bands * (m*bands + c) * np.sinc(bands * n)
    # Use L'Hospital's rule here for cos(nπf)/(πnf)**2 @ n=0
    b[0] -= m * bands * bands / 2.
    b[1:] += m * np.cos(n[1:] * np.pi * bands) / (np.pi * n[1:]) ** 2

info ~~warn~~ → info by review line-continuation-in-code scipy/signal/_lfilter.cc:59:78

backslash line continuation mid-expression (IOCCC-style obfuscation) (token pass, confidence 0.75)
```
        msg = PyUnicode_FromFormat("Unexpected shape for zi: expected (%"   \
                                    NPY_INTP_FMT ",), found (%" NPY_INTP_FMT \
                                    ",).", val, Vishape[0]);
        return msg;
```
dismissed LLM, confidence 0.93 Multi-line C format string using backslash continuations for an error message.
Reasoning
Backslash continuations inside a C string-concatenated macro format for an error message are standard style for long format strings; not obfuscation.

info unicode-mixed-script scipy/signal/_short_time_fft.py:2262:63

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

        ...     ax_.set_title(f"{center_bins=}")
        ...     ax_.set_xlabel(f"Time ({SFT.p_num(n)} points, Δt={SFT.delta_t})")
        ...     ax_.set_ylabel(f"Frequency ({SFT.f_pts} points, Δf={SFT.delta_f})")
        ...     ax_.set_xticks(SFT.t(n))  # vertical grid line are timestamps

info unicode-mixed-script scipy/signal/_short_time_fft.py:2263:65

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

        ...     ax_.set_xlabel(f"Time ({SFT.p_num(n)} points, Δt={SFT.delta_t})")
        ...     ax_.set_ylabel(f"Frequency ({SFT.f_pts} points, Δf={SFT.delta_f})")
        ...     ax_.set_xticks(SFT.t(n))  # vertical grid line are timestamps

info ~~warn~~ → info by review macro-keyword-override scipy/signal/_sigtoolsmodule.cc:56:1

`#define GOBACK goto` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)
```
#define GOBACK goto
#define DOloop(a,from,to) for ( (a) = (from); (a) <= (to); ++(a))
#define PI    3.14159265358979323846
```
likely benign LLM, confidence 0.85 Legacy C macro aliasing goto for control flow in sigtools.
Reasoning
Defining GOBACK as goto is a legacy C macro for control flow in the original Numerical Recipes-derived sigtools code; it is readable and not hiding malicious behavior, though unusual.
info ~~warn~~ → info by review dynamic-attribute scipy/signal/_support_alternative_backends.py:391:5

reach-by-name through `vars` (ast pass, confidence 0.60)
```
    # add the decorated function to the namespace, to be imported in __init__.py
    vars()[obj_name] = f
```
likely benign LLM, confidence 0.90 Registers decorated functions into module namespace via vars().
Reasoning
Same vars()-based namespace registration pattern as the ndimage counterpart, a legitimate backend dispatch technique.
info ~~warn~~ → info by review long-line scipy/signal/tests/test_windows.py:690:1

line length 5222 characters (raw pass, confidence 0.65)
```
    (100, 2, 4): ([[0.0030914414, 0.0041266922, 0.005315076, 0.006665149, 0.008184854, 0.0098814158, 0.011761239, 0.013829809, 0.016091597, 0.018549973, 0.02120712, 0.02406396, 0.027120092, 0.030373728, 0.033821651, 0.037459181, 0.041280145, 0.045276872, 0.049440192, 0.053759447, 0.058222524, 0.062815894, 0.067524661, 
```
likely benign LLM, confidence 0.95 Long line of hard-coded floating-point expected values in a test.
Reasoning
A very long line of numeric reference data in a test file is a normal artifact of embedding expected values; no executable or encoded payload is present.
info ~~warn~~ → info by review dynamic-attribute scipy/signal/windows/_windows.py:2607:14

reach-by-name through `vars` (ast pass, confidence 0.60)
```
for name in _names:
    window = vars()[name]
    window.__doc__ = doccer.docformat(window.__doc__, _xp_device_snippet)
```
likely benign LLM, confidence 0.85 Module-level loop uses vars() to fetch window functions by name to set docstrings.
Reasoning
vars()[name] is used to look up module-level window functions by name for docstring formatting, a common and benign metaprogramming idiom over a fixed list of names defined in the module.
info ~~warn~~ → info by review dynamic-attribute scipy/sparse/__init__.py:288:20

reach-by-name through `globals` (ast pass, confidence 0.60)
```
        try:
            return globals()[name]
        except KeyError:
            raise AttributeError(
```
likely benign LLM, confidence 0.85 Module __getattr__ returns a global by name, a standard lazy-loading idiom.
Reasoning
globals()[name] inside a module __getattr__ is the standard lazy-attribute pattern, raising AttributeError on KeyError; no untrusted input is involved.
info ~~warn~~ → info by review dynamic-execution scipy/sparse/csgraph/tests/test_graph_laplacian.py:43:15

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
    if not hasattr(mat, 'shape'):
        mat = eval(mat, dict(np=np, sparse=sparse))

    if sparse.issparse(mat):
```
likely benign LLM, confidence 0.80 Test helper evaluates string expressions to construct sparse/numpy matrices.
Reasoning
eval is applied to test-matrix descriptor strings in a test helper with a restricted namespace of only np and sparse. It is not attacker-controlled input in a shipped runtime path, though eval is poor practice.
info ~~warn~~ → info by review dynamic-execution scipy/sparse/csgraph/tests/test_graph_laplacian.py:299:20

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        if form == "array":
            d[L] = eval(L)
        else:
            d[L] = eval(L)(np.eye(n, dtype=mat.dtype))
```
likely benign LLM, confidence 0.85 Test code evaluates constructor name strings to build reference Laplacian matrices.
Reasoning
eval of test-local string names (such as Laplacian constructor names) in a test file to build expected results; benign test scaffolding with no external input.
info ~~warn~~ → info by review dynamic-execution scipy/sparse/csgraph/tests/test_graph_laplacian.py:301:20

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
        else:
            d[L] = eval(L)(np.eye(n, dtype=mat.dtype))

    _assert_allclose_sparse(d["Ls"], d["L_in"] + d["L_out"].T)
```
likely benign LLM, confidence 0.85 Test code evaluates constructor name strings for reference matrices.
Reasoning
Same pattern as the preceding finding: eval over hard-coded test identifiers in a test, not a dropper or runtime dynamic execution.
info ~~warn~~ → info by review macro-keyword-override scipy/sparse/linalg/_dsolve/SuperLU/SRC/colamd.c:765:1

`#define PRIVATE static` aliases a C reserved keyword behind a non-keyword macro name (ast pass, confidence 0.85)
```
#define PUBLIC
#define PRIVATE static

#define DENSE_DEGREE(alpha,n) \
```
likely benign LLM, confidence 0.85 Macro alias PRIVATE expands to the C keyword static in vendored SuperLU/COLAMD code.
Reasoning
Defining PRIVATE as static is a long-standing portability macro in the COLAMD sources (vendored SuperLU), not a malicious keyword aliasing; it is harmless.
info identifier-low-length scipy/sparse/linalg/_dsolve/SuperLU/SRC/qselect.c:1:1

60 of 122 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)
info identifier-low-length scipy/sparse/sparsetools/dense.h:1:1

62 of 147 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:1:1

line length 2499 characters (raw pass, confidence 0.65)
```
1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000
```
likely benign LLM, confidence 0.93 Test data file containing a long row of boolean values written as floats.
Reasoning
A data file of numeric 0/1 values in scientific format; long lines are expected for a matrix dump and there is no code or payload.
info ~~warn~~ → info by review narrow-file-charset scipy/spatial/tests/data/pdist-boolean-inp.txt:1:1

file uses only 5 distinct printable characters ("+.01e") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000
```
likely benign LLM, confidence 0.92 Numeric test data file uses few characters because it holds only 0/1 floats.
Reasoning
The narrow charset is inherent to a numeric matrix file containing only 0s and 1s with scientific notation; it is not JSF*ck-style obfuscation of code.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:2:1

line length 2499 characters (raw pass, confidence 0.65)

1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000

likely benign LLM, confidence 0.93 Test data row of boolean floats in a numeric data file.

Reasoning

Same benign numeric data file pattern; long line of formatted floats.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:3:1

line length 2499 characters (raw pass, confidence 0.65)

1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000

likely benign LLM, confidence 0.93 Test data row of boolean floats in a numeric data file.

Reasoning

Same benign numeric data file pattern; long line of formatted floats.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:4:1

line length 2499 characters (raw pass, confidence 0.65)
```
0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000
```
likely benign LLM, confidence 0.97 Wide whitespace-separated numeric test-data row in a SciPy pdist test fixture.
Reasoning
Raw long-line signal on a plain numeric test data file of boolean vectors formatted as floats. No executable content or obfuscation; the length is just wide numeric rows.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:5:1

line length 2499 characters (raw pass, confidence 0.65)
```
1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000
```
likely benign LLM, confidence 0.97 Wide numeric boolean-vector test-data row in SciPy.
Reasoning
Same pattern: a long row of 0/1 floats in a SciPy spatial test data file. Long lines in numeric data are expected and not malicious.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:6:1

line length 2499 characters (raw pass, confidence 0.65)
```
1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000
```
likely benign LLM, confidence 0.97 Wide numeric boolean-vector test-data row in SciPy.
Reasoning
Numeric 0/1 test fixture row; the long-line flag is a formatting artifact of the data file, not obfuscation.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:7:1

line length 2499 characters (raw pass, confidence 0.65)

1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000

likely benign LLM, confidence 0.97 Wide numeric boolean-vector test-data row in SciPy.

Reasoning

Plain numeric data row in a test fixture file; no code or encoded payload present.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:8:1

line length 2499 characters (raw pass, confidence 0.65)

1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000

likely benign LLM, confidence 0.97 Wide numeric boolean-vector test-data row in SciPy.

Reasoning

Numeric test data row with only 0/1 float values; the flag is solely line length.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:9:1

line length 2499 characters (raw pass, confidence 0.65)

1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000

likely benign LLM, confidence 0.97 Wide numeric boolean-vector test-data row in SciPy.

Reasoning

Numeric fixture row with no executable or encoded content; long-line signal only.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:10:1

line length 2499 characters (raw pass, confidence 0.65)

1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000

likely benign LLM, confidence 0.97 Wide numeric boolean-vector test-data row in SciPy.

Reasoning

Plain numeric 0/1 values in a test data file; nothing suspicious beyond line width.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:11:1

line length 2499 characters (raw pass, confidence 0.65)

0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000

likely benign LLM, confidence 0.97 Wide numeric boolean-vector test-data row in SciPy.

Reasoning

Numeric test fixture row; the raw long-line flag is a false positive for data files.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:12:1

line length 2499 characters (raw pass, confidence 0.65)

1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000

likely benign LLM, confidence 0.97 Wide numeric boolean-vector test-data row in SciPy.

Reasoning

Numeric data row with only float 0/1 values in a SciPy test fixture; no obfuscation.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:13:1

line length 2499 characters (raw pass, confidence 0.65)
```
1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000
```
likely benign LLM, confidence 0.97 A long row of boolean-valued float test data in a SciPy spatial test fixture.
Reasoning
The snippet is a row of 0/1 floats in scientific notation, the input format for SciPy's pdist boolean-distance tests. The long-line signal only reflects a very wide numeric row in a data file, with no code or encoded payload.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:14:1

line length 2499 characters (raw pass, confidence 0.65)
```
1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000
```
likely benign LLM, confidence 0.97 Another row of boolean test matrix data in a SciPy test fixture.
Reasoning
Same structure as the other rows: a long line of 0/1 floats in a SciPy test data file. The long-line warning is a formatting artifact of the fixture, not obfuscation.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:15:1

line length 2499 characters (raw pass, confidence 0.65)
```
0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000
```
likely benign LLM, confidence 0.97 A row of boolean float values in a SciPy test data file.
Reasoning
The snippet is a numeric 0/1 matrix row in a .txt fixture. Nothing executable or encoded is present, so the raw long-line finding is a false positive.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:16:1

line length 2499 characters (raw pass, confidence 0.65)
```
1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000
```
likely benign LLM, confidence 0.97 A numeric boolean matrix row in a SciPy pdist test input.
Reasoning
The content is plain whitespace-separated numeric data with the expected scientific notation. The file is a pdist test input and the warning comes from raw line length alone.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:17:1

line length 2499 characters (raw pass, confidence 0.65)
```
1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000
```
likely benign LLM, confidence 0.97 A boolean float data row in a SciPy spatial test fixture.
Reasoning
The snippet is a line of 0/1 floats in a SciPy test fixture. The raw pass flags length only, and the content has no suspicious structure.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:18:1

line length 2499 characters (raw pass, confidence 0.65)
```
0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000
```
likely benign LLM, confidence 0.97 A row of boolean numeric test data for SciPy distance tests.
Reasoning
This is a wide row of 0/1 numeric values in a test data file for boolean distance metrics. It is expected content for this fixture.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:19:1

line length 2499 characters (raw pass, confidence 0.65)
```
1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000
```
likely benign LLM, confidence 0.97 A numeric boolean data row in a SciPy pdist test fixture.
Reasoning
The line is numeric matrix data in a SciPy test input file. Long lines in generated numeric fixtures are normal and the content shows no code or encoding.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-boolean-inp.txt:20:1

line length 2499 characters (raw pass, confidence 0.65)
```
1.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 0.000000000000000000e+00 1.000000000000000000e+00 0.000000000000000000
```
likely benign LLM, confidence 0.97 A long row of floating-point numbers in a SciPy spatial test data file.
Reasoning
The file is a SciPy test data fixture of numeric values in scientific notation. A long line of 2499 characters is just a long row of numbers, a raw-pass long-line heuristic with no obfuscation or malicious content.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-chebyshev-ml-iris.txt:1:1

line length 178800 characters (raw pass, confidence 0.65)
```
   5.0000000e-01   4.0000000e-01   5.0000000e-01   1.0000000e-01   4.0000000e-01   5.0000000e-01   1.0000000e-01   7.0000000e-01   4.0000000e-01   3.0000000e-01   3.0000000e-01   5.0000000e-01   8.0000000e-01   7.0000000e-01   9.0000000e-01   4.0000000e-01   1.0000000e-01   6.0000000e-01   3.0000000e-01   3.0000000e-01
```
likely benign LLM, confidence 0.97 A very long line of decimal values in a SciPy Chebyshev distance test data file.
Reasoning
The snippet is a whitespace-separated numeric matrix from a Chebyshev distance test fixture, probably a machine-learning iris dataset. A 178800-character line is a generated data dump, and the raw long-line signal carries no evidence of malicious content.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-chebyshev-ml.txt:1:1

line length 3040 characters (raw pass, confidence 0.65)
```
   8.9084734e-01   9.3573853e-01   9.3507398e-01   9.6040691e-01   9.2918157e-01   9.6617342e-01   9.0430930e-01   9.5753424e-01   8.7106898e-01   9.2169905e-01   9.7401159e-01   8.9013416e-01   9.3956689e-01   9.0041896e-01   9.2588355e-01   9.3849417e-01   8.9713468e-01   9.1481804e-01   9.7500539e-01   9.0012586e-01
```
likely benign LLM, confidence 0.97 A long numeric data row in a SciPy pdist test fixture.
Reasoning
The snippet is a line of whitespace-separated floating-point numbers in a SciPy test data file for pdist. Long lines of numeric output are normal for test fixtures, and the raw long-line signal is a formatting heuristic with no obfuscation or code-execution content.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-cityblock-ml-iris.txt:1:1

line length 178800 characters (raw pass, confidence 0.65)
```
   7.0000000e-01   8.0000000e-01   1.0000000e+00   2.0000000e-01   1.2000000e+00   7.0000000e-01   3.0000000e-01   1.3000000e+00   8.0000000e-01   6.0000000e-01   6.0000000e-01   9.0000000e-01   1.7000000e+00   1.4000000e+00   1.8000000e+00   1.0000000e+00   1.0000000e-01   1.3000000e+00   5.0000000e-01   7.0000000e-01
```
likely benign LLM, confidence 0.97 A long row of numeric distance values from a SciPy iris test fixture.
Reasoning
The snippet is a row of decimal values from an iris-dataset distance fixture in SciPy's test data. The long line is a serialized numeric array, which is ordinary for this kind of file.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-cityblock-ml.txt:1:1

line length 3040 characters (raw pass, confidence 0.65)
```
   3.2420590e+01   3.3246607e+01   3.0526910e+01   3.5166573e+01   3.1868301e+01   3.6025002e+01   3.2513623e+01   3.6557796e+01   3.3752212e+01   3.4422130e+01   3.2526018e+01   3.2581161e+01   3.3743555e+01   3.6960777e+01   3.4225270e+01   3.2965308e+01   3.4591031e+01   3.4204203e+01   3.4678123e+01   3.5728720e+01
```
likely benign LLM, confidence 0.97 A long numeric row in a SciPy cityblock pdist test fixture.
Reasoning
The snippet is a whitespace-separated numeric row in a SciPy pdist test data file. It contains no code, encoding, or execution primitives, so the long-line warning is a false positive.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-correlation-ml-iris.txt:1:1

line length 178800 characters (raw pass, confidence 0.65)
```
   4.0013388e-03   2.6088954e-05   1.8315482e-03   6.5266850e-04   4.1394685e-04   1.1888069e-03   4.6185289e-04   1.9233577e-03   3.4480388e-03   1.5150632e-05   1.9126718e-03   3.0974734e-03   2.2295833e-04   2.4043394e-03   5.0134320e-03   3.0165570e-03   1.3145239e-04   6.0759419e-04   1.6672981e-03   4.0036132e-03
```
likely benign LLM, confidence 0.97 A long row of correlation distance values in a SciPy test fixture.
Reasoning
The snippet is a row of small floating-point values from a SciPy correlation-distance test fixture. Numeric data files of this shape routinely produce long lines, and nothing suggests hidden or malicious content.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-correlation-ml.txt:1:1

line length 3040 characters (raw pass, confidence 0.65)
```
   9.2507465e-01   9.6528566e-01   8.7255441e-01   1.1287379e+00   8.7318727e-01   1.0767102e+00   9.1419676e-01   1.1503304e+00   9.8074509e-01   1.0135025e+00   1.0495025e+00   9.4794536e-01   9.6829273e-01   1.1345767e+00   1.1048008e+00   9.2407796e-01   1.0228634e+00   9.3853195e-01   9.9377619e-01   1.0407662e+00
```
likely benign LLM, confidence 0.97 A long numeric row in a SciPy correlation pdist test fixture.
Reasoning
The snippet is a numeric data row in a SciPy pdist test fixture. The raw long-line flag fires on line length alone, and the content is plain numbers.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-cosine-ml-iris.txt:1:1

line length 178800 characters (raw pass, confidence 0.65)
```
   1.4208365e-03   1.2652718e-05   8.9939315e-04   2.4232332e-04   9.9747033e-04   9.2045721e-04   2.2040648e-04   8.6480051e-04   1.2354911e-03   5.3650090e-06   1.0275886e-03   1.1695784e-03   2.3556571e-04   1.4590172e-03   1.8981327e-03   1.0939621e-03   1.2392314e-04   3.5850877e-04   8.6078038e-04   1.4490833e-03
```
likely benign LLM, confidence 0.97 A long row of cosine distance values in a SciPy iris test fixture.
Reasoning
The snippet is a row of decimal values from a SciPy cosine-distance iris test fixture. It is serialized numeric data with no executable or encoded content.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-cosine-ml.txt:1:1

line length 3040 characters (raw pass, confidence 0.65)
```
   2.5695885e-01   2.6882042e-01   2.3470353e-01   2.9299329e-01   2.2742702e-01   3.1253572e-01   2.4986352e-01   3.0770122e-01   2.5191977e-01   2.7931567e-01   2.8133743e-01   2.6316239e-01   2.6067201e-01   3.2982339e-01   2.8993002e-01   2.5506356e-01   2.8728051e-01   2.4952121e-01   2.8613379e-01   2.6894157e-01
```
likely benign LLM, confidence 0.97 A long numeric row in a SciPy cosine pdist test fixture.
Reasoning
The snippet is a whitespace-separated numeric row in a SciPy test data file. The long-line warning is triggered only by its length, and the content is ordinary test data.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:1:1

line length 2499 characters (raw pass, confidence 0.65)
```
8.278938049410748956e-01 9.035293984476246987e-01 1.862188994679486731e-01 8.921151312310462433e-01 2.061859119379583216e-02 3.440636727385729676e-01 1.533779912830328662e-01 5.701372300009802663e-01 5.510020730211558915e-01 1.792362258426003496e-01 8.086175120876580857e-01 6.115487184317183189e-01 1.233471787164852618
```
likely benign LLM, confidence 0.96 A long line of high-precision float inputs in a SciPy test fixture.
Reasoning
The snippet is a line of high-precision decimal values in a SciPy test input file for double-precision pdist. Long lines of full-precision floats are expected for this fixture; there is no encoded blob or code.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:2:1

line length 2499 characters (raw pass, confidence 0.65)
```
8.033694116033356369e-01 8.653264545544031572e-01 7.468340410754038539e-01 6.362430919910603278e-01 5.120006306625468628e-02 9.503348372633585450e-01 4.697732609626817935e-01 4.221305288459429317e-01 3.153452119838391354e-01 2.991014843442657556e-01 1.190667967280257811e-01 3.486567714509342109e-01 8.289493649885054660
```
likely benign LLM, confidence 0.96 A second long line of high-precision float inputs in a SciPy test fixture.
Reasoning
The snippet is a second line of high-precision decimal values from the same SciPy double-precision pdist test input. It is numeric test data, so the long-line flag is a false positive.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:3:1

line length 2499 characters (raw pass, confidence 0.65)
```
9.287178470949695175e-01 1.748282433617460718e-01 9.238531711586964734e-01 8.291274445125006443e-01 9.513259272578692416e-01 7.486316801165745494e-01 6.257378457524477300e-01 2.062711693536473101e-01 3.970721244184766130e-01 2.738325225026445597e-01 8.735038948299954642e-01 5.415282140033768066e-01 5.176317904298315398
```
likely benign LLM, confidence 0.97 A scipy test data file containing a row of high-precision floats.
Reasoning
Plain-text numeric test data file of floating-point values; long lines are just wide rows of numbers from a scipy pdist test fixture. Raw pass long-line signal on a data file with no executable content.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:4:1

line length 2499 characters (raw pass, confidence 0.65)
```
2.599990881903107010e-01 6.767857524909899336e-01 7.188217446352963558e-01 3.037178903357997672e-01 4.252381412838680541e-01 4.070924411439535984e-02 8.426710493038247485e-02 8.301517457289483426e-01 8.254603255702420705e-01 7.258533909453509514e-01 9.958706809470796451e-01 1.323408451651194584e-01 8.523995455245143571
```
likely benign LLM, confidence 0.97 A scipy test data file containing a row of high-precision floats.
Reasoning
Same data-file pattern: a single 2499-character row of decimal floats in a scipy spatial test fixture. No code or encoded payload.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:5:1

line length 2499 characters (raw pass, confidence 0.65)
```
6.387761328141735584e-01 4.210087412162694109e-01 3.777306694964789324e-01 3.576349403292201634e-01 7.272699618880260619e-01 9.173392803607671731e-02 1.212535698300880593e-01 3.871229381194544183e-01 7.735150198351389284e-01 4.687200483013695962e-01 5.161778571874678923e-01 9.839646447226980674e-01 8.626932748911960713
```
likely benign LLM, confidence 0.97 A scipy test data file containing a row of high-precision floats.
Reasoning
Same numeric test fixture row; long-line flag is a false positive on wide numeric data.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:6:1

line length 2499 characters (raw pass, confidence 0.65)
```
5.539512747016193117e-01 6.329206647391879548e-01 2.798533500321682688e-01 4.825977295850051307e-01 7.625297023172977751e-01 9.081309101427640362e-01 4.124792086535029600e-01 3.647019658319609059e-01 7.529595202332928228e-02 3.072404010876803593e-01 7.890673660964639957e-01 4.079781478915127657e-01 1.440519120695739064
```
likely benign LLM, confidence 0.97 A scipy test data file containing a row of high-precision floats.
Reasoning
Numeric float row in a scipy test data file; no executable or obfuscated content.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:7:1

line length 2499 characters (raw pass, confidence 0.65)
```
5.714058727476275523e-01 7.913573761505965365e-02 9.301773447377043036e-01 4.302822433307075256e-01 4.618892554175407783e-01 1.882471300213742760e-01 6.231472878215863487e-01 2.350437450940777717e-01 8.483410480771292894e-01 8.580803842040533036e-01 4.246398783388435350e-01 5.667321565946502604e-01 7.247417018955526480
```
likely benign LLM, confidence 0.97 A scipy test data file containing a row of high-precision floats.
Reasoning
Numeric float row in a scipy test data file; long-line signal is a false positive.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:8:1

line length 2499 characters (raw pass, confidence 0.65)
```
7.705718397401561948e-01 3.165816092999733655e-01 4.334200859975760878e-01 8.639807015515663657e-01 5.576514209532534849e-03 2.456745447057938625e-01 1.664686313299922338e-01 9.637084729617834133e-01 1.083448720752323569e-01 1.865218070380464388e-01 3.730358890475884426e-01 5.015351872138350542e-01 7.420710795841709562
```
likely benign LLM, confidence 0.97 A scipy test data file containing a row of high-precision floats.
Reasoning
Numeric float row in a scipy test data file with no code or encoded payload.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:9:1

line length 2499 characters (raw pass, confidence 0.65)

8.154844535553099627e-01 4.797965609394789777e-01 7.476703385713100447e-01 9.086708404761600910e-01 3.191752505450355937e-01 7.611128630021511965e-01 6.246790343299296611e-01 1.942001426217137006e-01 2.789860414631386565e-01 3.236359785042408621e-02 3.178191288741717413e-01 8.372264298357038337e-01 8.872692914664047636

likely benign LLM, confidence 0.97 A scipy test data file containing a row of high-precision floats.

Reasoning

Numeric float row in a scipy test data file; benign wide-row data.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:10:1

line length 2499 characters (raw pass, confidence 0.65)
```
5.140190515373614932e-01 1.419225260054487459e-01 7.777845802285945354e-01 3.327562899409282071e-01 8.916875699762913943e-01 7.212852862736146564e-01 5.727327199433507321e-01 5.897820225918504189e-01 7.318614954542906892e-01 7.393985144455500480e-01 4.531340740296823100e-01 9.903061584426188224e-01 4.213350938331624773
```
likely benign LLM, confidence 0.97 A scipy test data file containing a row of high-precision floats.
Reasoning
Numeric float row in a scipy test fixture; long-line flag is a false positive.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:11:1

line length 2499 characters (raw pass, confidence 0.65)
```
4.746013333880729768e-01 7.609202966712714788e-01 2.537820854162747830e-01 1.709362234877408460e-01 1.886635378734374813e-01 2.439567014093724229e-02 7.640304718272151741e-01 3.483216170435471382e-01 7.744289278738043514e-01 4.190437573644867353e-01 5.319091476394965934e-02 8.580130976087452233e-01 6.259446446786639529
```
likely benign LLM, confidence 0.97 A scipy test data file containing a row of high-precision floats.
Reasoning
Numeric float row in a scipy test data file with no code or encoded content.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:12:1

line length 2499 characters (raw pass, confidence 0.65)
```
8.301526916287945701e-01 8.704609696144033348e-01 2.955689129581380303e-01 1.762209253489944727e-01 2.698172933050072553e-01 1.138095349991521399e-01 4.092588531860634760e-01 8.202978121681584467e-01 2.822241377079557356e-01 6.117376205659387223e-01 7.169923068016897938e-01 9.310256256264415331e-02 3.989664052931106708
```
dismissed LLM, confidence 0.97 Long line of floating-point numbers in a SciPy pdist test data file.
Reasoning
Plain-text numeric test fixture with long lines of random floats; a raw long-line signal on a data file is a known false positive with no code or execution content.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:13:1

line length 2499 characters (raw pass, confidence 0.65)
```
9.843444595454536872e-01 1.339523968066913540e-02 6.082172659959028671e-03 7.828244785439336662e-01 5.069653703872761819e-01 2.804896494365415327e-01 2.112385836660957139e-02 6.016479440778699228e-02 7.457477935084961818e-01 3.445503949245375397e-01 4.063494277166557200e-01 8.630275274433116817e-01 5.948396018456146850
```
dismissed LLM, confidence 0.97 Long line of floating-point numbers in a SciPy pdist test data file.
Reasoning
Same data fixture; only decimal numeric values, no executable or obfuscated content.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:14:1

line length 2499 characters (raw pass, confidence 0.65)
```
9.274935298374649140e-01 1.174096651033715855e-01 3.030761852629033637e-01 1.605508209527917174e-01 9.601854834873225775e-01 4.341959513718630648e-01 6.320768160802121560e-01 4.213429090614078110e-01 3.695553969042019160e-01 5.965457437116089556e-01 3.520335041155040479e-01 7.702703502247409961e-01 8.571112772962534709
```
dismissed LLM, confidence 0.97 Long line of floating-point numbers in a SciPy pdist test data file.
Reasoning
Same numeric test fixture; the long-line flag is a formatting artifact of the data file.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:15:1

line length 2499 characters (raw pass, confidence 0.65)
```
1.525818111800841814e-01 4.708012184002630107e-02 3.899035965341954846e-01 3.928304521031263929e-01 5.602286661727436945e-01 9.738256658043862313e-01 9.404465779766183475e-01 5.750862754958349088e-01 9.547546956257608741e-01 2.750275291553152535e-01 1.682773435862793265e-01 5.865928471016079726e-04 8.543378154943809255
```
dismissed LLM, confidence 0.97 Long line of floating-point numbers in a SciPy pdist test data file.
Reasoning
Numeric test data with no code semantics; raw long-line finding is a false positive.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:16:1

line length 2499 characters (raw pass, confidence 0.65)

6.398420210047787160e-01 5.739624494012524059e-01 3.359672805578653998e-01 1.130399363175038641e-02 3.349439685346782269e-01 2.315484030880912147e-01 4.575228302577399875e-01 1.149494135594463229e-01 2.888244352925943836e-01 3.625470995156252485e-01 3.795973190611611203e-01 6.567047810450010736e-01 1.484039742710284715

dismissed LLM, confidence 0.97 Long line of floating-point numbers in a SciPy pdist test data file.

Reasoning

Numeric fixture data; nothing suspicious in the snippet or file context.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:17:1

line length 2499 characters (raw pass, confidence 0.65)
```
9.709329844415439670e-01 8.998575745276288229e-01 9.151313462895852568e-01 6.920489275523904471e-01 2.892231405199537919e-01 6.750679746268205550e-01 5.515642485826798280e-01 1.065253097812824956e-01 2.957026803465776510e-01 8.937347659632134400e-01 9.800016515925590310e-01 7.745900896182087436e-01 1.570977683146633774
```
dismissed LLM, confidence 0.97 Long line of floating-point numbers in a SciPy pdist test data file.
Reasoning
Numeric fixture data consistent with a scientific test suite; raw long-line finding only.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:18:1

line length 2499 characters (raw pass, confidence 0.65)

4.894328120406804539e-01 7.881019629214267574e-01 6.974585354155089512e-01 2.023858939857701156e-01 1.660984914264745926e-01 4.854517801734643534e-01 2.789848572630315715e-01 2.311636522410289718e-01 9.821076233980715608e-01 1.220641257408076052e-01 2.614036146663852866e-01 7.657560715165320220e-01 3.968360577545695378

dismissed LLM, confidence 0.97 Long line of floating-point numbers in a SciPy pdist test data file.

Reasoning

Numeric test data; no encoded payload or executable content present.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:19:1

line length 2499 characters (raw pass, confidence 0.65)
```
5.185079639625639336e-01 9.613742991518259284e-01 5.555312825626229634e-01 2.647628827924735084e-01 6.003697207460141350e-01 5.392112376769145898e-01 6.781186965667050925e-01 9.908971748181496508e-01 4.124155872095397468e-01 9.814941401724619485e-02 2.684237785531295994e-02 1.774652505962848181e-01 1.707589529595294753
```
dismissed LLM, confidence 0.97 Long line of floating-point numbers in a SciPy pdist test data file.
Reasoning
Numeric test data; the long-line signal is a false positive for a plain data fixture.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-double-inp.txt:20:1

line length 2499 characters (raw pass, confidence 0.65)

5.015172758330755931e-01 5.569527971282052237e-01 1.122406928736449094e-01 8.960352822124777461e-01 6.049568585854003810e-02 1.202196001338627918e-01 1.870314295763603196e-01 9.017590029396971296e-01 3.597904628087450485e-01 2.130941062746317671e-01 2.556281834629479111e-01 5.123669364829196438e-01 4.754061129282013409

dismissed LLM, confidence 0.97 Long line of floating-point numbers in a SciPy pdist test data file.

Reasoning

Numeric test data with no obfuscation or malicious indicators.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-euclidean-ml-iris.txt:1:1

line length 178800 characters (raw pass, confidence 0.65)
```
   5.3851648e-01   5.0990195e-01   6.4807407e-01   1.4142136e-01   6.1644140e-01   5.1961524e-01   1.7320508e-01   9.2195445e-01   4.6904158e-01   3.7416574e-01   3.7416574e-01   5.9160798e-01   9.9498744e-01   8.8317609e-01   1.1045361e+00   5.4772256e-01   1.0000000e-01   7.4161985e-01   3.3166248e-01   4.3588989e-01
```
likely benign LLM, confidence 0.97 Test data file containing a long row of pairwise Euclidean distance values.
Reasoning
Plain numeric reference data in a test fixture; long lines of floats are expected for a flat matrix of pairwise distances.
info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-euclidean-ml.txt:1:1

line length 3040 characters (raw pass, confidence 0.65)
```
   4.0515260e+00   4.2121458e+00   3.7357405e+00   4.2313317e+00   3.9136009e+00   4.3843298e+00   3.9811426e+00   4.3624182e+00   4.0642508e+00   4.2105933e+00   4.0747226e+00   3.9068586e+00   4.1637004e+00   4.4303203e+00   4.1841564e+00   4.1063279e+00   4.1862390e+00   4.0719925e+00   4.2227579e+00   4.3173531e+00
```
likely benign LLM, confidence 0.97 Test data file with pairwise Euclidean distances on one long line.
Reasoning
Numeric test fixture of distance values; a long line is a formatting artifact of generated data, not obfuscation.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-hamming-ml.txt:1:1

line length 3040 characters (raw pass, confidence 0.65)

   4.6000000e-01   4.3000000e-01   4.3000000e-01   5.4000000e-01   4.1000000e-01   5.3000000e-01   4.3000000e-01   5.9000000e-01   4.8000000e-01   4.7000000e-01   4.6000000e-01   4.9000000e-01   4.5000000e-01   5.5000000e-01   5.3000000e-01   4.5000000e-01   4.8000000e-01   4.7000000e-01   4.8000000e-01   5.1000000e-01

likely benign LLM, confidence 0.97 Test fixture of pairwise Hamming distance values.

Reasoning

Numeric reference values for Hamming distance tests in SciPy; benign generated data.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-jaccard-ml.txt:1:1

line length 3040 characters (raw pass, confidence 0.65)

   6.5714286e-01   6.0563380e-01   6.3235294e-01   7.3972603e-01   6.0294118e-01   7.3611111e-01   6.4179104e-01   7.7631579e-01   6.4000000e-01   6.6197183e-01   6.6666667e-01   7.0000000e-01   6.4285714e-01   7.7464789e-01   7.1621622e-01   6.4285714e-01   6.8571429e-01   6.4383562e-01   6.6666667e-01   6.5384615e-01

likely benign LLM, confidence 0.97 Test fixture of pairwise Jaccard distance values.

Reasoning

Numeric reference data for Jaccard distance tests; long line is expected for this format.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-jensenshannon-ml-iris.txt:1:1

line length 172737 characters (raw pass, confidence 0.65)
```
0.0211635609063 0.00455072769716 0.0230610904531 0.0076674324982 0.037571216894 0.029561354778 0.0115281186735 0.0225809070507 0.0346801442638 0.00321049176948 0.0232839774828 0.0321124517082 0.0244179197971 0.0331466156799 0.0373949302575 0.0411984503375 0.0218945865519 0.0198268474453 0.02395616278 0.0254898420418 0.
```
likely benign LLM, confidence 0.96 Test fixture of Jensen-Shannon distance values computed on the iris dataset.
Reasoning
Generated numeric test data with long lines; no executable content or encoding concerns beyond size.
info ~~warn~~ → info by review narrow-file-charset scipy/spatial/tests/data/pdist-jensenshannon-ml-iris.txt:1:1

file uses only 11 distinct printable characters (".0123456789") — JSF*ck-style or character-constrained obfuscation (raw pass, confidence 0.90)
```
0.0211635609063 0.00455072769716 0.0230610904531 0.0076674324982 0.037571216894 0.029561354778 0.0115281186735 0.0225809070507 0.0346801442638 0.00321049176948 0.0232839774828 0.0321124517082 0.0244179197971 0.0331466156799 0.0373949302575 0.0411984503375 0.0218945865519 0.0198268474453 0.02395616278 0.0254898420418 0.
```
likely benign LLM, confidence 0.93 Numeric test data whose restricted character set comes from containing only decimal numbers.
Reasoning
A file of decimal floats naturally uses only digits and a period; the narrow charset is an artifact of numeric content, not character-constrained obfuscation of code.

info ~~warn~~ → info by review long-line scipy/spatial/tests/data/pdist-jensenshannon-ml.txt:1:1

line length 2817 characters (raw pass, confidence 0.65)

0.320369972991 0.338972466 0.308199372323 0.3452431902 0.310024768313 0.357115225615 0.311131096357 0.357391534414 0.329718053755 0.347365921475 0.335272625287 0.336451560653 0.33015370606 0.369628769749 0.344499490029 0.321622508707 0.345377707016 0.321007207534 0.350728979121 0.32809430086 0.30207071308 0.29166325249

likely benign LLM, confidence 0.97 Test data file of Jensen-Shannon distance values.

Reasoning

Numeric test fixture of distance values; the long line is benign data formatting.

info identifier-low-length scipy/spatial/transform/_rotation_groups.py:1:1

207 of 425 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)
info identifier-low-length scipy/special/tests/test_zeta.py:1:1

120 of 284 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info unicode-mixed-script scipy/stats/_continuous_distns.py:10214:46

identifier `πi` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
# same as above, but using -exp(x) = exp(x + πi)
def _log_diff(log_p, log_q):
    return sc.logsumexp([log_p, log_q+np.pi*1j], axis=0)
```

info unicode-mixed-script scipy/stats/_correlation.py:52:13

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

    # "Suppose that X and Y are independent and Y is continuous. Then
    # √n·ξn(X, Y) → N(0, 2/5) in distribution as n → ∞"
    if y_continuous:  # [1] Theorem 2.1
        return xp.asarray(math.sqrt(2 / 5) / math.sqrt(n), dtype=r.dtype)

info unicode-mixed-script scipy/stats/_correlation.py:56:57

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


    # "Suppose that X and Y are independent. Then √n·ξn(X, Y)
    # converges to N(0, τ²) in distribution as n → ∞
    # [1] Eq. 2.2 and surrounding math

info ~~critical~~ → info by review dynamic-execution scipy/stats/_distn_infrastructure.py:369:5

`exec` called on a constructed string (ast pass, confidence 0.80)
```
for obj in [s for s in dir() if s.startswith('_doc_')]:
    exec('del ' + obj)
del obj
```
likely benign LLM, confidence 0.85 Cleanup code that runs exec to delete module-level _doc_ helper names built from dir().
Reasoning
The exec call deletes docstring variables from the namespace using a constructed string 'del ' + obj where obj comes from dir() filtered to names starting with '_doc_'. This is a known SciPy idiom for cleaning up module-level docstring helpers; the input is locally generated, not attacker-controlled. Still exec is unusual and worth noting.
info unicode-homoglyph scipy/stats/tests/test_multivariate.py:1817:9

identifier `ν` contains homoglyph candidates: ν (03BD)→v (in string/comment) (raw pass, confidence 0.35)
```
        Random.seed!(42)
        ν = 5
        M = [1 2 3; 4 5 6]
        Σ = PDMats.PDMat([1 0.5; 0.5 1])
```

info unicode-homoglyph scipy/stats/tests/test_multivariate.py:1821:28

identifier `ν` contains homoglyph candidates: ν (03BD)→v (in string/comment) (raw pass, confidence 0.35)

        Ω = PDMats.PDMat([1 0.3 0.2; 0.3 1 0.4; 0.2 0.4 1])
        dist = MatrixTDist(ν, M, Σ, Ω)
        samples = rand(dist, 10)
        pdfs = [pdf(dist, s) for s in samples]

info identifier-low-length subprojects/pyprima/pyprima/pyprima/tests/test_pycutest.py:1:1

333 of 721 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)

info high-complexity subprojects/qhull_r/libqhull_r/global_r.c:1641:37

compression ratio 0.870 is >2σ above file mean 0.805 (raw pass, confidence 0.50)

  if (qh->JOGGLEmax < REALmax/2 && REALepsilon > 2e-8 && qh->PRINTprecision)
    qh_fprintf(qh, qh->ferr, 7039, "qhull warning: real epsilon, %2.2g, is probably too large for joggle('QJn')\nRecompile with double precision reals(see user_r.h).\n",
          REALepsilon);
#ifdef qh_NOmerge

info unicode-homoglyph tools/check_unicode.py:19:22

identifier `αβγδεζηθικλμνξπρστυϕχψω` contains homoglyph candidates: α (03B1)→a, η (03B7)→n, κ (03BA)→k, ν (03BD)→v (in string/comment) (raw pass, confidence 0.35)

latin1_letters = set(chr(cp) for cp in range(192, 256))
greek_letters = set('αβγδεζηθικλμνξπρστυϕχψω' + 'ΓΔΘΛΞΠΣϒΦΨΩ')
box_drawing_chars = set(chr(cp) for cp in range(0x2500, 0x2580))
extra_symbols = set('®ő∫≠≥≤±∞²³·→√°✅⛔⚠⟨U+FE0F⟩')

info unicode-mixed-script tools/check_unicode.py:19:22

identifier `αβγδεζηθικλμνξπρστυϕχψω` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)

latin1_letters = set(chr(cp) for cp in range(192, 256))
greek_letters = set('αβγδεζηθικλμνξπρστυϕχψω' + 'ΓΔΘΛΞΠΣϒΦΨΩ')
box_drawing_chars = set(chr(cp) for cp in range(0x2500, 0x2580))
extra_symbols = set('®ő∫≠≥≤±∞²³·→√°✅⛔⚠⟨U+FE0F⟩')

info ~~critical~~ → info by review dynamic-import tools/refguide_check.py:525: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.80 Dynamic __import__ of a module whose name is supplied by the tool's caller.
Reasoning
A developer tool dynamically importing a module by name is expected behavior for a reference-guide checker that accepts module names from its command line; no encoded payload or hidden source is shown. The non-literal import is a legitimate pattern here.

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/scipy/scipy scipy && cd scipy
git checkout v1.18.1
disclude scan --severity info --diff v1.18.0 .