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: 2320 scanned, 712 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 45 warn · 155 info
Scan time: 84.1 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): the 107 most severe of 152 warn and critical signals (107 with a verdict); 107 demoted to info. The rest are unreviewed.
Disclude version: 4.1.0
Scanned (UTC): 2026-10-22 01:18

Signals

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

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
```
likely benign LLM, confidence 0.90 Numeric data file in a benchmark directory.
Reasoning
Plain numeric data table of digits and spaces, typical of CUTEst benchmark data; a narrow charset here is just numeric content, not JSF*ck-style 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.85 eval of a module-attribute lookup string in a benchmark.
Reasoning
eval on 'stats.' + dist_name is a known scipy benchmark idiom for selecting a distribution by name from a trusted internal module; the constructed string is a fixed prefix with an internal name, not untrusted input.
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
```
likely benign LLM, confidence 0.80 Dynamic import of Sphinx extension names during docs configuration.
Reasoning
Sphinx conf tries importing extension names in a loop with try/except, a standard docs build pattern with names from a fixed 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 Greek letter pi in release-note prose.
Reasoning
The Greek pi in a release note is mathematical text (exp(±iπ/3)), not an identifier spoofing; mixed script in prose is benign.
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 Dotted-path object resolver for documentation.
Reasoning
Standard Sphinx helper resolving a dotted object path via __import__ and getattr; the name comes from documentation directives, not untrusted input.

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 Greek pi in FFT math documentation.
Reasoning
Greek pi in a math formula within reStructuredText prose; not an identifier and no code risk.

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(
```
likely benign LLM, confidence 0.85 Lazy attribute lookup in scipy package init.
Reasoning
Module __getattr__ lazily resolving submodule names from globals() is a standard lazy-loading idiom; the lookup is by attribute name only and raises AttributeError otherwise.
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 Caller frame lookup in the tempita template engine.
Reasoning
sys._getframe is used by the tempita templating library to find the caller's namespace for template defaults; the co-occurrence with exec/eval is inherent to a template engine, 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.85 Template expression evaluation in tempita.
Reasoning
Tempita evaluates template expressions by design; this is the expected core of a templating engine running build-time templates from the source tree.
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.85 Template code block execution in tempita.
Reasoning
Tempita executes template code blocks by design, part of the templating engine's documented function.
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.85 Eval of CLI-supplied template variable value.
Reasoning
The eval of a variable value in tempita's command-line variable handling is intended behavior for a template tool invoked by the developer.
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.90 exec of generated class source in Bunch factory.
Reasoning
This is the standard namedtuple-style exec of a generated class template built from typename and field names, 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.80 bz2 decompression of the bundled face dataset.
Reasoning
Decompressing a bz2 data file for the scipy.datasets face image is ordinary data loading; pickle is imported for other fetch paths and the payload is a known dataset file, not executed code.
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;
```
likely benign LLM, confidence 0.80 Similar short local double variables in QUADPACK C code.
Reasoning
Short C variable names b1 and b2 among many similar names; the confusable collision is an artifact of the skeleton normalization on single-letter identifiers, not deliberate spoofing of a shadowed symbol.
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};
```
likely benign LLM, confidence 0.90 Local variable declarations in the QUADPACK C translation.
Reasoning
Short C variable names such as ll, l1 and I-like names in a Fortran-translated numerical routine collide visually. Identifiers are ordinary C variables with no sign of concealed behaviour.
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.92 Macro providing a Fortran-integer alias for int.
Reasoning
`#define F_INT int` is a common portability typedef-style macro in SciPy's Fortran/C interface headers. It does not hide executable behaviour.
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);
```
likely benign LLM, confidence 0.90 Function prototype parameters in the dfitpack C translation.
Reasoning
Confusable skeleton from ordinary parameter names (c0, c1, co-style names) in a Fortran-derived parameter list. Typical of legacy numerical code.
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;
```
likely benign LLM, confidence 0.90 Local integer declarations in dfitpack.c.
Reasoning
Integer locals such as i1, il and I-like names trigger the confusable check. This is ordinary Fortran-style numerical naming.
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];
```
likely benign LLM, confidence 0.90 Loop indexing in the spline solver.
Reasoning
Index variables l0, l1 and similar are the kind of names the confusable heuristic flags in translated spline code. No hidden logic is visible.
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++;
```
likely benign LLM, confidence 0.90 Local spline variables and loop increments.
Reasoning
Names tl and t|-style identifiers in spline index arithmetic are routine. The finding comes from the visual-skeleton heuristic alone.
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];
```
likely benign LLM, confidence 0.90 Integer and double local declarations in dfitpack.c.
Reasoning
Declarations such as n1 and numy1 are normal in translated Fortran numerical code. The collision is a naming artefact.
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];
```
likely benign LLM, confidence 0.90 Local integer declarations in a surface-fitting routine.
Reasoning
Long lists of short generated-style names (lau, lav1, id0 and similar) are typical of the Fortran port. Confusable matches are not evidence of obfuscation.
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.90 Decompresses a record from an IDL save file.
Reasoning
zlib decompression of IDL SAVE record data is the expected job of an IDL file reader. The payload is a file the user supplies, not an embedded dropper.
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.92 Expected binary NetCDF file contents in a unit test.
Reasoning
The bytes literal spells out a NetCDF binary header as a test fixture. Heavy hex escapes are expected for binary test data.
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.80 Registers decorated backend functions into the module namespace.
Reasoning
Assigning into vars() is how this module publishes decorated functions into the package namespace for later import. It is a dynamic-namespace pattern, not a hidden reach-by-name attack.
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;
```
likely benign LLM, confidence 0.90 Local variable declarations in the ndimage filter code.
Reasoning
Short identifiers ll, ii and jj in an image-filter C routine generate the confusable match. The code is ordinary numerical C.
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
```
likely benign LLM, confidence 0.95 Text fixture of labelled image results used by tests.
Reasoning
The file is a plain test fixture of digit grids for labelling results. A digits-only charset is expected for that content and is not an obfuscated payload.
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.75 Builds a wrapper function from generated source and fetches it by name.
Reasoning
exec runs generated wrapper source in a controlled namespace to build a function with a specific signature, a known pattern in SciPy's nonlinear solver code. The source is produced internally rather than from untrusted input, though the non-literal exec is worth a light check.
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.80 Dynamic __import__ of a module path built from a dotted name string.
Reasoning
The snippet resolves a dotted name from a split string, imports the parent module, then getattr's the target. This is a common lazy-import pattern for resolving named callables inside a library, not an attempt to hide a payload.
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.85 Reads local variables by name to build a kwargs dict.
Reasoning
locals().get is used to collect optional keyword arguments by name from the function's own scope. It is a readable, if unusual, idiom with no sign of concealed behavior.
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.85 Test evaluates repr of a Bounds object to verify round-tripping.
Reasoning
This is a unit test that round-trips a Bounds object through repr and eval to check that its representation is valid. The eval input is the test's own repr output, 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.85 Accesses module-level window functions by name to reformat docstrings.
Reasoning
vars() is used to fetch window functions defined in the module namespace so their docstrings can be formatted. This is a standard documentation-build pattern in scipy.

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.90 Multi-line C format string built with backslash continuations for an error message.
Reasoning
Backslash continuations splitting a printf-style format string across C string literals are ordinary C preprocessor style for long messages. Nothing here is encoded or hidden, and the code is a readable error message.

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 macro aliasing goto for early exit in a numerical C module.
Reasoning
GOBACK is a legacy macro in a long-standing numerical C codebase, used for an early-exit jump. It is a common historical style rather than a concealed control-flow trick, and it has a legitimate role here.
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.80 Registers decorated functions into the module namespace via vars().
Reasoning
vars() assignment registers a decorated function in the module namespace so __init__ can import it. This is a deliberate registration pattern for backend dispatch, and the same pattern appears elsewhere in scipy.
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, 
```
dismissed LLM, confidence 0.90 Long line containing numeric expected values in a test fixture.
Reasoning
This is a very long line of numeric reference data in a test file. Long numeric literal tables are common in test fixtures, and the content is plain numbers.
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 Accesses window functions by name via vars() to reformat docstrings.
Reasoning
The same vars() lookup of window functions to format docstrings appears in the windows module. It is ordinary documentation-generation code.
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.90 Module __getattr__ that looks up names in globals() and raises AttributeError on miss.
Reasoning
This is the standard module-level __getattr__ pattern for lazy or deprecated attribute access, raising AttributeError on a miss. It is a well-known Python idiom.
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 a string matrix expression with a limited namespace.
Reasoning
eval is applied to a test-supplied matrix expression with a restricted namespace of numpy and sparse. The input comes from the test suite, not from untrusted data.
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.80 Test evaluates a Laplacian constructor name from a fixed test table.
Reasoning
eval resolves a Laplacian constructor name from a fixed test-table key. It is a test convenience and not reachable with attacker-controlled 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.80 Test evaluates a Laplacian constructor name in an else branch.
Reasoning
This is the same eval-by-name pattern in a parametrized test branch, operating on fixed test identifiers.
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 Vendored C macro mapping PRIVATE to static.
Reasoning
PRIVATE is defined as static in the vendored SuperLU/COLAMD C source, a long-standing convention in that code. It is a portability and style macro with no concealment.
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
```
dismissed LLM, confidence 0.90 Long line of numeric values in a spatial test data file.
Reasoning
This is a numeric test data file with long rows of floats. Long lines in plain-text numeric datasets are expected and carry no executable or hidden content.
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.97 Numeric test fixture of boolean vectors for scipy pdist tests.
Reasoning
This is a plain numeric test-data file of boolean vectors written in scientific notation. A small character set (digits, dot, e, plus, minus, space) is the natural consequence of numeric data, not JSF*ck-style obfuscation. The file sits in a scipy test data directory and is inert.
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.97 Long numeric data row in a scipy spatial test fixture.
Reasoning
Long lines are a byproduct of the fixed-width numeric matrix format in a test data file. The content is plain 0/1 floats with no executable or encoded payload.
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.97 Numeric data row in a scipy spatial test fixture.
Reasoning
Same as the other rows: a long line of 0/1 floats in a scientific test data file. No obfuscation or malicious intent is evident.
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 Numeric data row in a scipy spatial test fixture.
Reasoning
A long numeric row of boolean-valued floats. This is expected content for a pdist test input file and carries no payload.
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 Numeric data row in a scipy spatial test fixture.
Reasoning
Long numeric row of 0/1 floats in a test data file. The long-line signal reflects formatting, not obfuscation.
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 Numeric data row in a scipy spatial test fixture.
Reasoning
Numeric boolean-vector row in a scipy test fixture. The long line is just wide matrix formatting.
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 Numeric data row in a scipy spatial test fixture.
Reasoning
Numeric 0/1 float row in a scientific test data file. No encoding, execution, or hidden content is 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 Numeric data row in a scipy spatial test fixture.
Reasoning
Boolean-valued numeric matrix row in a test fixture. The flagged long line is ordinary data layout.
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 Numeric data row in a scipy spatial test fixture.
Reasoning
Numeric 0/1 row from a scipy test data file. No obfuscation is present; the signal is triggered by formatting alone.
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 Numeric data row in a scipy spatial test fixture.
Reasoning
Numeric boolean-vector row in a scipy test fixture. The long line and narrow charset both follow from the numeric content and are not malicious.
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.95 A row of 0/1 floats in a SciPy spatial distance test data file.
Reasoning
The line is a long run of zero/one floats written in scientific notation, which is the expected layout of a numeric test fixture for pdist with boolean inputs. Nothing in it is executable, encoded, or hidden. The long-line warning is a formatting artifact.
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.95 A row of 0/1 floats in a SciPy spatial distance test data file.
Reasoning
Same pattern as the other rows of this data file: a numeric matrix row of 0/1 values in a SciPy test fixture. The long-line finding reflects wide numeric data, not 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.95 A row of 0/1 floats in a SciPy spatial distance test data file.
Reasoning
A plain numeric data row of 0/1 floats within a test input file for boolean distance computations. No code or encoded payload is present.
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.95 A row of 0/1 floats in a SciPy spatial distance test data file.
Reasoning
Plain numeric matrix data in a SciPy test fixture. The long line is only wide formatting of 0/1 floats.
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.95 A row of 0/1 floats in a SciPy spatial distance test data file.
Reasoning
Numeric test data of 0/1 floats with no executable or encoded content. This is a normal fixture for testing boolean pairwise distances.
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.95 A row of 0/1 floats in a SciPy spatial distance test data file.
Reasoning
A row of 0/1 floats written in scientific notation, typical of a SciPy test input file. No sign of obfuscation.
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.95 A row of 0/1 floats in a SciPy spatial distance test data file.
Reasoning
Plain numeric data in a test fixture. The long-line signal flags only the width of the row.
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.95 A row of 0/1 floats in a SciPy spatial distance test data file.
Reasoning
A numeric data row in a SciPy test input file, with no executable or encoded content.
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.95 A row of 0/1 floats in a SciPy spatial distance test data file.
Reasoning
Numeric test fixture content consisting only of 0/1 floats. The long line is not a sign of obfuscation.
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.95 A row of 0/1 floats in a SciPy spatial distance test data file.
Reasoning
A row of 0/1 floats in a SciPy test data file. The finding comes from line length alone and reflects no malicious pattern.
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.95 A large numeric matrix of decimal values in a SciPy pdist test data file for the iris dataset.
Reasoning
This is a single very long line of decimal values from a SciPy test fixture for Chebyshev pdist on the iris dataset. It is a data file, not code, and the long line is a serialization artifact of a large numeric matrix.
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
```
dismissed LLM, confidence 0.97 A SciPy test data file containing a long line of floating-point distance values.
Reasoning
Raw long-line signal on a text data file of floating-point numbers from SciPy's test suite. Numeric test fixtures naturally produce long lines; no obfuscation or malicious content is present.
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
```
dismissed LLM, confidence 0.97 A SciPy test fixture holding a very long line of numeric pdist results.
Reasoning
Long line of numeric values in a SciPy spatial test fixture (iris dataset distances). Entirely consistent with legitimate test data.
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
```
dismissed LLM, confidence 0.97 A SciPy test data file with a long line of numeric distance values.
Reasoning
Numeric test data in SciPy's test directory; the long-line flag is a formatting artifact of a generated fixture.
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
```
dismissed LLM, confidence 0.97 A SciPy test fixture of correlation distance values on one long line.
Reasoning
Plain numeric distance output in a SciPy test fixture; no code, encoding, or hidden instructions.
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
```
dismissed LLM, confidence 0.97 A SciPy test data file of correlation distances on a long line.
Reasoning
Generated numeric test data from SciPy; the long line is expected for this fixture type.

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

dismissed LLM, confidence 0.97 A SciPy test fixture of cosine distance values on a long line.

Reasoning

Numeric cosine-distance fixture in SciPy tests; benign formatting of test data.

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

dismissed LLM, confidence 0.97 A SciPy test data file of cosine distances on one long line.

Reasoning

Generated numeric test data within SciPy's test tree; no malicious indicators.

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
```
dismissed LLM, confidence 0.97 A SciPy test input file of double-precision numbers on a long line.
Reasoning
Double-precision numeric input fixture for SciPy pdist tests; long lines of digits are expected.

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

dismissed LLM, confidence 0.97 Second line of the SciPy double-precision pdist input fixture.

Reasoning

Same fixture as line 1, consisting only of decimal numbers; benign test data.

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

dismissed LLM, confidence 0.97 Third line of the SciPy double-precision pdist input fixture.

Reasoning

Continuation of the numeric SciPy test fixture; no encoded payload or obfuscation.

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

dismissed LLM, confidence 0.97 Fourth line of the SciPy double-precision pdist input fixture.

Reasoning

Fourth line of the same numeric SciPy test fixture; benign floating-point values.

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 long line of floating-point test data in a SciPy spatial test fixture.
Reasoning
Plain-text test fixture of random floating-point numbers used for pdist tests; long lines are just numeric data rows, with no code or encoded payload.
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 long numeric data row in a SciPy pdist test fixture.
Reasoning
Same pattern: numeric data rows in a legitimate scipy test data file, flagged only for line length.
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 long numeric data row in a SciPy pdist test fixture.
Reasoning
Numeric test input data with a long-line warning only; no executable or obfuscated content.
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 long numeric data row in a SciPy pdist test fixture.
Reasoning
Random float values in a text fixture for distance computation tests; raw long-line signal is a known false positive for data files.
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 long numeric data row in a SciPy pdist test fixture.
Reasoning
Numeric test data in a legitimate scipy fixture; nothing suspicious beyond line length.
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 long numeric data row in a SciPy pdist test fixture.
Reasoning
Plain numeric fixture data; the long-line finding reflects data layout, not obfuscation.

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 long numeric data row in a SciPy pdist test fixture.

Reasoning

Numeric values in a test input file; benign raw-pass long-line false positive.

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

likely benign LLM, confidence 0.97 A long numeric data row in a SciPy pdist test fixture.

Reasoning

Random floating-point test data in a scipy fixture file; no code or hidden 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
```
likely benign LLM, confidence 0.97 A long numeric data row in a SciPy pdist test fixture.
Reasoning
Numeric test data; the flag is purely on line length in a data file within a legitimate project.
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
```
likely benign LLM, confidence 0.97 A long numeric data row in a SciPy pdist test fixture.
Reasoning
Fixture of random doubles used by scipy's spatial tests; long-line warning is a false positive.
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
```
likely benign LLM, confidence 0.97 A long numeric data row in a SciPy pdist test fixture.
Reasoning
Numeric test input data in a legitimate scipy test directory; no obfuscation indicators.
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 A row of double-precision test input values in a SciPy spatial test data file.
Reasoning
The snippet is a row of high-precision floating-point numbers in a SciPy test-data text file. The long line is just a flattened numeric vector, with no code, encoding, or execution involved. The raw-pass long-line signal is a formatting artifact.
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 A row of double-precision test input values in a SciPy spatial test data file.
Reasoning
Same file and pattern: a long line of decimal floating-point values used as pdist test input. No obfuscation or malicious content is present.
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 A row of double-precision test input values in a SciPy spatial test data file.
Reasoning
Same file and pattern: a long line of decimal floating-point values used as pdist test input. The long-line signal reflects data layout only.
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 A row of double-precision test input values in a SciPy spatial test data file.
Reasoning
Same file and pattern: a long line of decimal floating-point values used as pdist test input. Nothing suggests encoding or hidden payload.
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 A row of double-precision test input values in a SciPy spatial test data file.
Reasoning
Same file and pattern: a long line of decimal floating-point values used as pdist test input. This is ordinary numeric test data.
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
```
dismissed LLM, confidence 0.97 A flattened array of Euclidean pairwise distances in a SciPy test fixture.
Reasoning
The file is a SciPy test fixture holding a single flattened array of pairwise Euclidean distances in scientific notation. The 178 KB single line is a serialization choice, not obfuscation.
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
```
dismissed LLM, confidence 0.97 A flattened array of Euclidean pairwise distances in a SciPy test fixture.
Reasoning
A SciPy test fixture of pairwise Euclidean distance values in scientific notation. The long line is expected for a flattened numeric array.
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
```
dismissed LLM, confidence 0.97 A flattened array of Hamming pairwise distances in a SciPy test fixture.
Reasoning
A SciPy test fixture of pairwise Hamming distance values. It is plain numeric data, and the long line is just layout.
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
```
dismissed LLM, confidence 0.97 A flattened array of Jaccard pairwise distances in a SciPy test fixture.
Reasoning
A SciPy test fixture of pairwise Jaccard distance values. It is ordinary numeric reference data for a test.
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.
```
dismissed LLM, confidence 0.97 A flattened array of Jensen-Shannon pairwise distances in a SciPy test fixture.
Reasoning
A SciPy test fixture of pairwise Jensen-Shannon distance values. The 172 KB line is a single serialized numeric array, which is typical for generated scientific test data.
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.97 Numeric reference data for SciPy jensenshannon pdist tests.
Reasoning
Numeric test data file of floating-point distances; a narrow charset of digits and dot is expected for numeric data. Raw pass, no malicious content.
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.96 Numeric pdist test data with a long line of floats.
Reasoning
Long line of whitespace-separated floats in a test data file; a long line is typical for matrix dumps.
info ~~warn~~ → info by review 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
```
likely benign LLM, confidence 0.96 Numeric pdist test data flagged for narrow charset.
Reasoning
Same numeric test data file; the charset signal reflects ordinary decimal numbers, not obfuscation.
info ~~warn~~ → info by review 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
```
likely benign LLM, confidence 0.97 Minkowski distance reference values for SciPy tests.
Reasoning
Scientific test fixture of formatted floats in a long line; no code or execution content.

info ~~warn~~ → info by review 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

likely benign LLM, confidence 0.97 Minkowski distance reference values for SciPy tests.

Reasoning

Numeric test fixture with long line of floats; benign data file.

info ~~warn~~ → info by review 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

likely benign LLM, confidence 0.97 Minkowski 5.8 distance reference values for SciPy tests.

Reasoning

Numeric test fixture of formatted floats; benign.

info ~~warn~~ → info by review 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

likely benign LLM, confidence 0.97 Seuclidean pdist reference values for SciPy tests.

Reasoning

Numeric standardized-Euclidean test fixture; long line is expected for data dumps.

info ~~warn~~ → info by review 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

likely benign LLM, confidence 0.97 Seuclidean pdist reference values for SciPy tests.

Reasoning

Numeric test fixture with long lines of floats; no executable content.

info ~~warn~~ → info by review 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

likely benign LLM, confidence 0.97 Spearman pdist reference values for SciPy tests.

Reasoning

Numeric Spearman distance test data; long line of floats is benign.

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.90 Module-level cleanup that execs 'del' on names of _doc_ helpers from dir().
Reasoning
Deleting docstring variables from the namespace via exec on a constructed string 'del ' + name is an unusual idiom, but the names come from dir() filtered to '_doc_' prefixes, a common SciPy pattern for cleaning up module-level docstring helpers. The input is not attacker-controlled; this is a known legitimate pattern.
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.85 Dynamic __import__ of a module name inside a SciPy docs-checking tool.
Reasoning
A dynamic import of a module name in a developer tooling script that checks reference docs is a normal pattern; the module name comes from the tool's own workflow rather than untrusted input. Context not shown, but nothing indicates malice.

Reproduce This Scan

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

cargo install disclude --version 4.1.0
git clone https://github.com/scipy/scipy scipy && cd scipy
git checkout v1.18.1
disclude scan --severity info --diff v1.18.0 .