ruff 0.17.0

Source: https://github.com/astral-sh/ruff
Tag scanned: 0.17.0
Compared with: 0.16.10 (13 signals introduced since)
Files: 6728 scanned, 4451 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 32 warn · 578 info
Scan time: 80.6 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): the 100 most severe of 132 warn and critical signals (100 with a verdict); 100 demoted to info. The rest are unreviewed.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-14 18:26

Signals

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

warn narrow-file-charset crates/ruff_python_formatter/resources/test/fixtures/black/cases/power_op_spacing_long.py:1:1

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

a = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1
b = 1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1**1
c = 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1 ** 1

warn high-complexity crates/ruff_python_formatter/resources/test/fixtures/black/cases/preview_long_strings__east_asian_width.py:5:10

string literal compression ratio 0.970 (132 bytes) (raw pass, confidence 0.60)

hangul = '코드포인트 수는 적으나 실제 터미널이나 에디터에서 렌더링될 땐 너무 길어서 줄바꿈이 필요한 문자열'
hanzi = '中文測試：代碼點數量少，但在真正的終端模擬器或編輯器中呈現時太長，因此需要換行的字符串。'

warn unicode-invisible crates/ruff_python_formatter/resources/test/fixtures/black/cases/tricky_unicode_symbols.py:4:2

U+E0100 VARIATION SELECTOR SUPPLEMENT (invisible payload carrier, encodes byte 0x10) in source (raw pass, confidence 0.90)
```
蟒 = 3
x⟨U+E0100⟩ = 4
មុ = 1
Q̇_per_meter = 4
```
warn dynamic-execution crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/lambda.py:845:5

`subprocess.check_call` called with `shell=True` and a literal command (ast pass, confidence 0.70)
```
def foo():
    subprocess.check_call(f"rm -rf {' '.join(map(lambda object_name: os.path.join(dest_path, object_name), objects_to_remove))}", shell=True)

def bar():
```

warn dynamic-execution crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/lambda.py:858:5

`subprocess.check_call` called with `shell=True` and a literal command (ast pass, confidence 0.70)

def foo():
    subprocess.check_call(f"rm -rf {' '.join(map(lambda object_name: max(candidate_paths, key=lambda candidate: os.path.join(dest_path, object_name, candidate)), objects_to_remove))}", shell=True)

# Regression test for https://github.com/astral-sh/ruff/issues/25397

warn encoding-hex crates/ruff_python_parser/src/string.rs:939:78

18 consecutive `\xNN` escapes (entropy 4.2 bits/byte) (raw pass, confidence 0.65)

\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\

warn encoding-escape-soup crates/ruff_python_parser/src/string.rs:939:247

129 consecutive `\xNN` escapes (entropy 7.0 bits/byte) (raw pass, confidence 0.80)

NOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\x

warn encoding-hex crates/ruff_python_parser/src/string.rs:947:78

18 consecutive `\xNN` escapes (entropy 4.2 bits/byte) (raw pass, confidence 0.65)

\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\

warn encoding-escape-soup crates/ruff_python_parser/src/string.rs:947:247

129 consecutive `\xNN` escapes (entropy 7.0 bits/byte) (raw pass, confidence 0.80)

NOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\x

warn long-line crates/ty_python_semantic/resources/corpus/03_dict_unpack_huge.py:1:1

line length 2903 characters (raw pass, confidence 0.65)

{**{0:1},**{1:2},**{2:3},**{3:4},**{4:5},**{5:6},**{6:7},**{7:8},**{8:9},**{9:10},**{10:11},**{11:12},**{12:13},**{13:14},**{14:15},**{15:16},**{16:17},**{17:18},**{18:19},**{19:20},**{20:21},**{21:22},**{22:23},**{23:24},**{24:25},**{25:26},**{26:27},**{27:28},**{28:29},**{29:30},**{30:31},**{31:32},**{32:33},**{33:34

warn unicode-mixed-script crates/ty_python_semantic/resources/mdtest/type_properties/quantification.md:19:20

identifier `Dᵧ` mixes scripts: Latin + Other (raw pass, confidence 0.80)

| E5   | `∃X ∈ {int, str}. C(X, Y, Z)`    | Solutions remain paired with each choice    |
| E6   | `∀Y ∈ Dᵧ. ∃X ∈ Dₓ. R(X, Y)`      | `X` may depend on the choice of `Y`         |

```toml

warn unicode-mixed-script crates/ty_python_semantic/resources/mdtest/type_properties/quantification.md:19:35

identifier `Dₓ` mixes scripts: Latin + Other (raw pass, confidence 0.80)

| E5   | `∃X ∈ {int, str}. C(X, Y, Z)`    | Solutions remain paired with each choice    |
| E6   | `∀Y ∈ Dᵧ. ∃X ∈ Dₓ. R(X, Y)`      | `X` may depend on the choice of `Y`         |

```toml

warn unicode-zero-width crates/ty_python_semantic/resources/mdtest/typed_dict.md:368:23

U+200B ZERO WIDTH SPACE in source (raw pass, confidence 0.75)
```
Also, the value types ⟨U+200B⟩⟨U+200B⟩declared in a `TypedDict` affect generic call inference:

```py
```
warn unicode-zero-width crates/ty_python_semantic/resources/mdtest/typed_dict.md:368:26

U+200B ZERO WIDTH SPACE in source (raw pass, confidence 0.75)
```
Also, the value types ⟨U+200B⟩⟨U+200B⟩declared in a `TypedDict` affect generic call inference:

```py
```
warn dynamic-execution docs/faq.md:244:3

[embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)
```
$ # On macOS and Linux.
$ curl -LsSf https://astral.sh/ruff/install.sh | sh

$ # On Windows.
```

warn dynamic-execution docs/faq.md:250:3

[embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)

$ # For a specific version.
$ curl -LsSf https://astral.sh/ruff/0.5.0/install.sh | sh
$ powershell -c "irm https://astral.sh/ruff/0.5.0/install.ps1 | iex"
```

warn dynamic-execution docs/installation.md:39:3

[embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)
```
$ # On macOS and Linux.
$ curl -LsSf https://astral.sh/ruff/install.sh | sh

$ # On Windows.
```

warn dynamic-execution docs/installation.md:45:3

[embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)

$ # For a specific version.
$ curl -LsSf https://astral.sh/ruff/0.5.0/install.sh | sh
$ powershell -c "irm https://astral.sh/ruff/0.5.0/install.ps1 | iex"
```

warn dynamic-execution scripts/generate_builtin_modules.py:76:16

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
    ]
    return set(eval(run(command_2)))
```
warn dynamic-execution scripts/ty_benchmark/README.md:4:14

[markup prose] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)
```
    - Unix: `curl -LsSf https://astral.sh/uv/install.sh | sh`
```

warn long-line scripts/ty_benchmark/snapshots/homeassistant_Pyright.txt:19250:1

line length 2112 characters (raw pass, confidence 0.65)

  <CWD>/homeassistant/components/lg_thinq/sensor.py:429:81 - error: Type "dict[str, tuple[SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, SensorEntityDescription, Senso

warn long-line scripts/ty_benchmark/snapshots/pandas_Pyrefly.txt:1352:1

line length 2416 characters (raw pass, confidence 0.65)

ERROR pandas/io/parsers/readers.py:317:5-13: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'

warn long-line scripts/ty_benchmark/snapshots/pandas_Pyrefly.txt:1353:1

line length 2400 characters (raw pass, confidence 0.65)

ERROR pandas/io/parsers/readers.py:327:5-13: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'

warn long-line scripts/ty_benchmark/snapshots/pandas_Pyrefly.txt:1354:1

line length 2412 characters (raw pass, confidence 0.65)

ERROR pandas/io/parsers/readers.py:337:5-13: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'

warn long-line scripts/ty_benchmark/snapshots/pandas_Pyrefly.txt:1355:1

line length 2425 characters (raw pass, confidence 0.65)

ERROR pandas/io/parsers/readers.py:347:5-13: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'

warn long-line scripts/ty_benchmark/snapshots/pandas_Pyrefly.txt:1356:1

line length 2416 characters (raw pass, confidence 0.65)

ERROR pandas/io/parsers/readers.py:904:5-15: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'

warn long-line scripts/ty_benchmark/snapshots/pandas_Pyrefly.txt:1357:1

line length 2400 characters (raw pass, confidence 0.65)

ERROR pandas/io/parsers/readers.py:914:5-15: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'

warn long-line scripts/ty_benchmark/snapshots/pandas_Pyrefly.txt:1358:1

line length 2412 characters (raw pass, confidence 0.65)

ERROR pandas/io/parsers/readers.py:924:5-15: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'

warn long-line scripts/ty_benchmark/snapshots/pandas_Pyrefly.txt:1359:1

line length 2425 characters (raw pass, confidence 0.65)

ERROR pandas/io/parsers/readers.py:934:5-15: Implementation signature `(filepath_or_buffer: PathLike[str] | ReadCsvBuffer[bytes] | ReadCsvBuffer[str] | str, *, sep: _NoDefault | str | None = _NoDefault.no_default, delimiter: _NoDefault | str | None = None, header: Literal['infer'] | Sequence[int] | int | None = 'infer'

warn long-line scripts/ty_benchmark/snapshots/pandas_ty.txt:126:1

line length 8782 characters (raw pass, confidence 0.65)

pandas/core/array_algos/datetimelike_accumulations.py:38:22: error[invalid-argument-type] Method `__getitem__` of type `bound method dict[(bound method _UFunc_Nin2_Nout1[Literal["maximum"], Literal[21], None].accumulate(array: _Buffer | _SupportsArray[dtype[Any]] | _NestedSequence[_SupportsArray[dtype[Any]]] | ... omit

warn long-line scripts/ty_benchmark/snapshots/pandas_ty.txt:127:1

line length 20747 characters (raw pass, confidence 0.65)

pandas/core/array_algos/masked_accumulations.py:56:22: error[invalid-argument-type] Method `__getitem__` of type `bound method dict[Overload[(a: _SupportsArray[dtype[numpy.bool[builtins.bool]]] | _NestedSequence[_SupportsArray[dtype[numpy.bool[builtins.bool]]]] | builtins.bool | _NestedSequence[builtins.bool], axis: Su

warn long-line scripts/ty_benchmark/snapshots/pytorch_ty.txt:1329:1

line length 4221 characters (raw pass, confidence 0.65)

torch/_dynamo/polyfills/itertools.py:314:1: error[invalid-argument-type] Argument is incorrect: Expected `Overload[[_T1, _T_co](iter1: Iterable[_T1], /, *, fillvalue: object = None) -> zip_longest[tuple[_T1]] | zip_longest[tuple[_T1@__new__ | Any, _T2@__new__ | Any]] | zip_longest[tuple[_T1@__new__ | _T@__new__, _T2@__

info long-line .github/workflows/release.yml:313:1 new in this release

line length 613 characters (raw pass, confidence 0.50)

    if: ${{ always() && needs.plan.result == 'success' && needs.plan.outputs.publishing == 'true' && needs.sign-release-binaries.result == 'success' && needs.generate-checksum-manifest.result == 'success' && (needs.build-global-artifacts.result == 'skipped' || needs.build-global-artifacts.result == 'success') && (needs

info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:358:11 new in this release

[embedded bash] command name is a variable () not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
          fi
          "${python[@]}" -m pip install wheels/"$TARGET"/ruff-*.whl --force-reinstall --no-index --no-deps
          ruff --version
          ruff --help
```
likely benign LLM, confidence 0.85 Installs a signed ruff wheel with the configured Python interpreter and checks the CLI.
Reasoning
`${python[@]}` is a bash array holding the interpreter invocation, set earlier in the workflow. The step installs the signed wheel and runs `ruff --help`. The variable-command flag is the array expansion, not hidden code.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:361:11 new in this release

[embedded bash] command name is a variable () not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
          ruff --help
          "${python[@]}" -m ruff --help
```
likely benign LLM, confidence 0.85 Post-install smoke test of ruff via the configured Python interpreter.
Reasoning
Runs `python -m ruff --help` through the same array-based interpreter variable as the preceding step, as a post-install check.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:418:11 new in this release

[embedded bash] command name is a variable (`$ErrorActionPreference`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
          $ErrorActionPreference = 'Stop'
          $wheel = Get-ChildItem -LiteralPath "wheels/$env:TARGET" -Filter 'ruff-*.whl'
          if (@($wheel).Count -ne 1) { throw 'Expected exactly one signed wheel' }
```
likely benign LLM, confidence 0.85 Assignment of the PowerShell ErrorActionPreference variable in a release signing workflow step.
Reasoning
This is PowerShell inside a workflow step where $ErrorActionPreference is a standard preference variable assignment, not a command invocation. The scanner misparsed the embedded bash/pwsh block as shell; the 'command name' is a false parse of an assignment line.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:419:11 new in this release

[embedded bash] command name is a variable (`$wheel`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
          $ErrorActionPreference = 'Stop'
          $wheel = Get-ChildItem -LiteralPath "wheels/$env:TARGET" -Filter 'ruff-*.whl'
          if (@($wheel).Count -ne 1) { throw 'Expected exactly one signed wheel' }
          python -m pip install $wheel.FullName --force-reinstall --no-index --no-deps
```
likely benign LLM, confidence 0.85 Locating the single signed ruff wheel and installing it in a release workflow.
Reasoning
$wheel is a Get-ChildItem result assigned in the script and then used as a file path to pip install a wheel from a directory that was just verified to contain exactly one signed wheel. The flag is a parser artifact of PowerShell syntax, not dynamic execution of attacker-controlled commands.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:420:17 new in this release

[embedded bash] command name is a variable (`$wheel`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
          $wheel = Get-ChildItem -LiteralPath "wheels/$env:TARGET" -Filter 'ruff-*.whl'
          if (@($wheel).Count -ne 1) { throw 'Expected exactly one signed wheel' }
          python -m pip install $wheel.FullName --force-reinstall --no-index --no-deps
```
likely benign LLM, confidence 0.85 Installing the located signed wheel with pip in the release workflow.
Reasoning
Same pattern as the adjacent finding: $wheel.FullName is passed as an argument to python -m pip install. The variable is not the command name; the scanner misread the line. The step verifies the artifact count before installing.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:422:15 new in this release

[embedded bash] command name is a variable (`$LASTEXITCODE`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
          python -m pip install $wheel.FullName --force-reinstall --no-index --no-deps
          if ($LASTEXITCODE -ne 0) { throw 'Signed wheel installation failed' }
          ruff --version
          if ($LASTEXITCODE -ne 0) { throw 'Signed executable failed' }
```
likely benign LLM, confidence 0.85 Checking the exit code after wheel installation in the release workflow.
Reasoning
$LASTEXITCODE is the standard PowerShell exit-status variable used in a comparison, not an executed command. The check guards the preceding pip install. This is a parser false positive.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:424:15 new in this release

[embedded bash] command name is a variable (`$LASTEXITCODE`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
          ruff --version
          if ($LASTEXITCODE -ne 0) { throw 'Signed executable failed' }
          ruff --help
          if ($LASTEXITCODE -ne 0) { throw 'Signed executable help failed' }
```
likely benign LLM, confidence 0.85 Exit-code check after running ruff --version in the release workflow.
Reasoning
$LASTEXITCODE comparison after invoking the ruff executable to verify it runs. Standard PowerShell error handling; the flagged token is a variable read, not a command name.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:426:15 new in this release

[embedded bash] command name is a variable (`$LASTEXITCODE`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
          ruff --help
          if ($LASTEXITCODE -ne 0) { throw 'Signed executable help failed' }
          python -m ruff --help
          if ($LASTEXITCODE -ne 0) { throw 'Signed module invocation failed' }
```
likely benign LLM, confidence 0.85 Exit-code check after smoke-testing the installed ruff module.
Reasoning
$LASTEXITCODE comparison after ruff --help and python -m ruff --help smoke tests. Routine verification of the signed artifact; the flag stems from treating a variable read as a command.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:428:15 new in this release

[embedded bash] command name is a variable (`$LASTEXITCODE`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
          python -m ruff --help
          if ($LASTEXITCODE -ne 0) { throw 'Signed module invocation failed' }
```
likely benign LLM, confidence 0.85 Exit-code check after module invocation smoke test in the release workflow.
Reasoning
$LASTEXITCODE comparison after python -m ruff --help smoke test. Standard PowerShell exit-status check with no dynamic execution of untrusted input.
info ~~warn~~ → info by review dynamic-execution README.md:153:1 new in this release

[embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)
```
# For a specific version.
curl -LsSf https://astral.sh/ruff/0.17.0/install.sh | sh
powershell -c "irm https://astral.sh/ruff/0.17.0/install.ps1 | iex"
```
likely benign LLM, confidence 0.80 README instructions for installing a pinned ruff version via curl and PowerShell pipelines.
Reasoning
Pinned-version install instructions from the official astral.sh domain, including a PowerShell irm piped to iex. Standard documented installer pattern; the dynamic execution is intentional and disclosed.
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/functools_partial.md:918:1 new in this release

[embedded python] 16 of 34 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info ~~warn~~ → info by review unicode-mixed-script crates/ty_python_semantic/resources/mdtest/import/star.md:1023:1 new in this release

[embedded python] identifier `__aℓℓ__` mixes scripts: Latin + Other (raw pass, confidence 0.80)
```
__all__ = ["first"]
__aℓℓ__.append("second")
```
```
likely benign LLM, confidence 0.78 Mdtest snippet where a Unicode lookalike identifier is used alongside `__all__`, likely to test name-resolution behaviour.
Reasoning
The snippet uses a confusable identifier, `__aℓℓ__`, with a script-mixed lowercase l (U+2113) instead of `__all__`. The surrounding test sets `__all__` and then appends to the lookalike name, which looks like a deliberate test of how name resolution treats confusable identifiers in a type checker's test suite. The raw pass has a higher false-positive rate, and there is no execution or payload here.
info ~~warn~~ → info by review dynamic-execution .github/workflows/build-binaries.yml:73:13

[embedded bash] command name is a variable (`$MODULE_NAME`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
            pip install /dist/"${PACKAGE_NAME}"-*.tar.gz --force-reinstall
            "${MODULE_NAME}" --help
            python -m "${MODULE_NAME}" --help
```
likely benign LLM, confidence 0.90 CI smoke test that runs the installed package's entry point via a variable name.
Reasoning
MODULE_NAME is a workflow-supplied package entry-point name used for a post-install smoke test (`--help`). It is a CI verification step, not attacker-controlled execution, and the snippet shows nothing that fetches or decodes code.
info ~~critical~~ → info by review dynamic-execution .github/workflows/build-binaries.yml:252:11

[embedded bash] command name is a variable (`$LLVM_READOBJ`) and `LLVM_READOBJ` is assigned the output of a command — executed command determined at runtime (ast pass, confidence 0.90)
```
          IMPORTS_FILE="$RUNNER_TEMP/ruff-coff-imports.txt"
          "$LLVM_READOBJ" --coff-imports "target/${{ matrix.platform.target }}/release/ruff.exe" > "$IMPORTS_FILE"

          if grep -Eiq 'vcruntime[[:digit:]_]*\.dll|api-ms-win-crt-' "$IMPORTS_FILE"; then
```
likely benign LLM, confidence 0.75 Windows build step that lists the COFF imports of ruff.exe with llvm-readobj to verify runtime DLL dependencies.
Reasoning
LLVM_READOBJ is a path to llvm-readobj, used to dump COFF imports of the built ruff.exe so the workflow can grep for the MSVC/UCRT runtime DLLs. The variable is assigned from a command, which is the flagged part, but this is a standard Windows build-verification step. The critical severity is an overstatement for a build-time check.
info ~~warn~~ → info by review dynamic-execution .github/workflows/build-binaries.yml:263:11

[embedded bash] command name is a variable (`$MODULE_NAME`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
          python -m pip install dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
          "${MODULE_NAME}" --help
          python -m "${MODULE_NAME}" --help
```
likely benign LLM, confidence 0.90 Post-install smoke test of the built wheel's module entry point.
Reasoning
Same pattern as the other MODULE_NAME smoke tests: a workflow-defined module name is run with --help after installing the built wheel. Routine release verification.
info ~~warn~~ → info by review dynamic-execution .github/workflows/build-binaries.yml:332:13

[embedded bash] command name is a variable (`$MODULE_NAME`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
            pip install /dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
            "${MODULE_NAME}" --help
            python -m "${MODULE_NAME}" --help
```
likely benign LLM, confidence 0.90 Install-and-smoke-test step for the built package.
Reasoning
Identical MODULE_NAME smoke-test pattern in another job, running `--help` on the freshly installed package. No obfuscation or untrusted input is involved.
info ~~warn~~ → info by review dynamic-execution .github/workflows/build-binaries.yml:405:13

[embedded bash] command name is a variable (`$MODULE_NAME`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
            pip install /dist/"${PACKAGE_NAME}"-*.whl --force-reinstall
            "${MODULE_NAME}" --help
            python -m "${MODULE_NAME}" --help
```
likely benign LLM, confidence 0.90 Install-and-smoke-test step for the built package.
Reasoning
Same routine MODULE_NAME smoke test after installing the package from the /dist artifact directory.
info ~~warn~~ → info by review dynamic-execution .github/workflows/build-binaries.yml:560:13

[embedded bash] command name is a variable (`$MODULE_NAME`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
            .venv/bin/pip3 install "${PACKAGE_NAME}" --no-index --find-links /dist --force-reinstall
            .venv/bin/"${MODULE_NAME}" --help
```
likely benign LLM, confidence 0.90 Venv install and smoke test of the packaged CLI.
Reasoning
A venv-based install followed by running the module's `--help`. This is the usual verification for a release artifact, with the name set by the workflow.
info ~~warn~~ → info by review dynamic-execution .github/workflows/build-binaries.yml:629:13

[embedded bash] command name is a variable (`$MODULE_NAME`) not set in this file — the caller or environment decides what runs (ast pass, confidence 0.70)
```
            .venv/bin/pip3 install "${PACKAGE_NAME}" --no-index --find-links /dist --force-reinstall
            .venv/bin/"${MODULE_NAME}" --help
```
likely benign LLM, confidence 0.90 Venv install and smoke test of the packaged CLI.
Reasoning
Same venv install and `--help` smoke test as the preceding job, with no untrusted input.
info ~~warn~~ → info by review dynamic-execution .github/workflows/ci.yaml:385:11

[embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)
```
          curl --proto '=https' --tlsv1.2 -LsSf \
            "https://github.com/astral-sh/hawk/releases/download/${HAWK_VERSION}/cargo-hawk-installer.sh" | sh
```
likely benign LLM, confidence 0.75 Installs the pinned cargo-hawk binary by piping the official release installer script to sh.
Reasoning
The script is fetched over HTTPS from the official astral-sh GitHub release for a pinned HAWK_VERSION and piped to sh. This is the standard cargo-dist installer pattern, and TLS 1.2 is enforced. It is a supply-chain trust decision, not obfuscation, so the signal is valid but the risk is low.
info identifier-low-length .github/workflows/ci.yaml:466:14

[embedded bash] 14 of 35 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info ~~warn~~ → info by review dynamic-execution CONTRIBUTING.md:484:19

[markup prose] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)
```
1. Install `uv`: `curl -LsSf https://astral.sh/uv/install.sh | sh`
```
likely benign LLM, confidence 0.80 Documentation instructing contributors to install uv via curl piped to sh.
Reasoning
This is the widely used uv installer one-liner in contributor docs, piping a remote script from the project's official domain into sh. It is a known curl-pipe-sh pattern that is documented, not hidden obfuscation, though it does execute remote code by design.
info ~~warn~~ → info by review dynamic-execution README.md:147:1

[embedded bash] pipeline feeds into `sh` — piped data is executed as shell code (ast pass, confidence 0.80)
```
# On macOS and Linux.
curl -LsSf https://astral.sh/ruff/install.sh | sh

# On Windows.
```
likely benign LLM, confidence 0.80 README install instructions for ruff via curl piped to sh on macOS and Linux.
Reasoning
Official ruff installation instructions piping the install script from astral.sh to sh. This is the documented, vendor-hosted install method rather than malicious code, though curl-pipe-sh carries inherent trust risk.

info long-line changelogs/0.11.x.md:217:1

line length 555 characters (raw pass, confidence 0.50)

- Add fix safety sections (`ASYNC116`, `FLY002`, `D200`, `RUF005`, `RUF017`, `RUF027`, `RUF028`, `RUF057`) ([#17497](https://github.com/astral-sh/ruff/pull/17497), [#17496](https://github.com/astral-sh/ruff/pull/17496), [#17502](https://github.com/astral-sh/ruff/pull/17502), [#17484](https://github.com/astral-sh/ruff/p

info long-line changelogs/0.14.x.md:632:1

line length 606 characters (raw pass, confidence 0.50)

    - \[`refurb`\] [`FURB105`](https://github.com/astral-sh/ruff/pull/22767), [`FURB116`](https://github.com/astral-sh/ruff/pull/22681), [`FURB136`](https://github.com/astral-sh/ruff/pull/22680), [`FURB140`](https://github.com/astral-sh/ruff/pull/22679), [`FURB145`](https://github.com/astral-sh/ruff/pull/22670), [`FURB

info high-complexity crates/mdtest/src/parser.rs:2378:14

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

            err.to_string(),
            "Unknown HTML comment `snpshotttt-digggggnosstic` -- possibly a typo? \
            (Add to `HTML_COMMENT_ALLOWLIST` if this is a false positive)",
        );

info high-complexity crates/ruff/src/commands/format.rs:1243:22

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

                warn_user_once!(
                    "The isort option `isort.lines-between-types` with a value greater than 1 is incompatible with the formatter. To avoid unexpected behavior, we recommend setting the option to one of: `1` or `0` (default)."
                );
            }

info whitespace-anomaly crates/ruff/tests/cli/lint.rs:17:1

file mixes tab and space indentation (2 tab-indented and 3800 space-indented lines) (raw pass, confidence 0.40)

impl CliTest {
    fn check_command(&self) -> Command {
        let mut command = self.command();
        command.args(STDIN_BASE_OPTIONS);

info whitespace-anomaly crates/ruff_annotate_snippets/tests/color/multiline_removal_suggestion.rs:2:1

file mixes tab and space indentation (39 tab-indented and 40 space-indented lines) (raw pass, confidence 0.40)
```
use annotate_snippets::{
    AnnotationKind, Level, Origin, Patch, Renderer, Snippet, renderer::DecorStyle,
};
```

info unicode-mixed-script crates/ruff_annotate_snippets/tests/formatter.rs:2991:58

identifier `Aͫ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

  |  ___________^
4 | |     { name = "Z͑ͫ̓ͪ̂ͫ̽⟨U+034F⟩̴̙̤̞͉͚̯̞̠͍A̴̵̜̰͔ͫ͗͢L̠ͨͧͩ͘G̴̻͈͍͔̹̑͗̎̅͛́Ǫ̵̹̻̝̳͂̌̌͘", email = 1 }
5 | | ]
  | |_^ annotation

info unicode-mixed-script crates/ruff_annotate_snippets/tests/formatter.rs:2991:75

identifier `Lͨͧͩ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

  |  ___________^
4 | |     { name = "Z͑ͫ̓ͪ̂ͫ̽⟨U+034F⟩̴̙̤̞͉͚̯̞̠͍A̴̵̜̰͔ͫ͗͢L̠ͨͧͩ͘G̴̻͈͍͔̹̑͗̎̅͛́Ǫ̵̹̻̝̳͂̌̌͘", email = 1 }
5 | | ]
  | |_^ annotation

info unicode-mixed-script crates/ruff_annotate_snippets/tests/formatter.rs:3005:62

identifier `Aͫ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

  │ ┏━━━━━━━━━━━┛
4 │ ┃     { name = "Z͑ͫ̓ͪ̂ͫ̽⟨U+034F⟩̴̙̤̞͉͚̯̞̠͍A̴̵̜̰͔ͫ͗͢L̠ͨͧͩ͘G̴̻͈͍͔̹̑͗̎̅͛́Ǫ̵̹̻̝̳͂̌̌͘", email = 1 }
5 │ ┃ ]
  ╰╴┗━┛ annotation

info unicode-mixed-script crates/ruff_annotate_snippets/tests/formatter.rs:3005:79

identifier `Lͨͧͩ` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

  │ ┏━━━━━━━━━━━┛
4 │ ┃     { name = "Z͑ͫ̓ͪ̂ͫ̽⟨U+034F⟩̴̙̤̞͉͚̯̞̠͍A̴̵̜̰͔ͫ͗͢L̠ͨͧͩ͘G̴̻͈͍͔̹̑͗̎̅͛́Ǫ̵̹̻̝̳͂̌̌͘", email = 1 }
5 │ ┃ ]
  ╰╴┗━┛ annotation

info unicode-mixed-script crates/ruff_annotate_snippets/tests/formatter.rs:3368:64

identifier `Ӻi` mixes scripts: Cyrillic + Latin (in string/comment) (raw pass, confidence 0.40)

��|�\u{0002}!5�cc\u{0015}\u{0002}�Ӻi��WWj�ȥ�'�}�\u{0012}�J�ȉ��W�\u{001e}O�@����\u{001c}w�V���LO����\u{0014}[ \u{0003}_�'���SQ�~ذ��ų&��-\t��lN~��!@␌ _#���kQ��h⟨U+E1C5⟩�⟨U+F3C1⟩\u{001d}�:�\u{001c}\u{0007}�";

info unicode-mixed-script crates/ruff_annotate_snippets/tests/formatter.rs:3396:31

identifier `Ӻi` mixes scripts: Cyrillic + Latin (in string/comment) (raw pass, confidence 0.40)

  |
1 | �|�␂!5�cc␕␂�Ӻi��WWj�ȥ�'�}�␒�J�ȉ��W�␞O�@����␜w�V���LO����␔[ ␃_�'���SQ�~ذ��ų&��-    ��lN~��!@␌ _#���kQ��h⟨U+E1C5⟩�⟨U+F3C1⟩␝�:�␜␇�
  | ^

info unicode-mixed-script crates/ruff_annotate_snippets/tests/formatter.rs:3414:33

identifier `Ӻi` mixes scripts: Cyrillic + Latin (in string/comment) (raw pass, confidence 0.40)

  │
1 │ �|�␂!5�cc␕␂�Ӻi��WWj�ȥ�'�}�␒�J�ȉ��W�␞O�@����␜w�V���LO����␔[ ␃_�'���SQ�~ذ��ų&��-    ��lN~��!@␌ _#���kQ��h⟨U+E1C5⟩�⟨U+F3C1⟩␝�:�␜␇�
  │ ━

info whitespace-anomaly crates/ruff_annotate_snippets/tests/rustc_tests.rs:12:1

file mixes tab and space indentation (1 tab-indented and 3952 space-indented lines) (raw pass, confidence 0.40)
```
fn ends_on_col0() {
    let source = r#"
fn foo() {
}
```
info ~~warn~~ → info by review whitespace-anomaly crates/ruff_annotate_snippets/tests/rustc_tests.rs:4533:3

invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)
```
    let s = c"foo\
  ⟨U+00A0⟩          bar
             ";
    //~^^^ WARNING whitespace symbol '\u{a0}' is not skipped
```
likely benign LLM, confidence 0.95 Rust test fixture containing a non-breaking space inside a C string literal test case.
Reasoning
The U+00A0 is inside a test string literal demonstrating how the whitespace symbol is handled by the Rust compiler/test harness; it is a deliberate test fixture for annotate-snippets, not an obfuscation attempt in code.
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/eradicate/ERA001.py:8:1

file mixes tab and space indentation (2 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)
```
def foo(x, y, z):
    content = 1 # print('hello')
    print(x, y, z)
```
info ~~critical~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC22x.py:73:5

`os.spawnl` with a non-literal binary path — runtime-determined process spawn (ast pass, confidence 0.85)
```
    # if mode is given, and is not os.P_WAIT: ASYNC220
    os.spawnl(os.P_NOWAIT)  # ASYNC220
    os.spawnl(P_NOWAIT)  # ASYNC220
    os.spawnl(mode=os.P_NOWAIT)  # ASYNC220
```
likely benign LLM, confidence 0.90 Ruff linter fixture calling os.spawnl with os.P_NOWAIT, marked by ASYNC220 test comment.
Reasoning
This is a linter test fixture for ruff's flake8-async rules; os.spawnl calls are intentionally written to trigger ASYNC220 and are not executed malicious code. The critical severity is an artifact of the scanner, not real intent.
info ~~critical~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC22x.py:74:5

`os.spawnl` with a non-literal binary path — runtime-determined process spawn (ast pass, confidence 0.85)
```
    os.spawnl(os.P_NOWAIT)  # ASYNC220
    os.spawnl(P_NOWAIT)  # ASYNC220
    os.spawnl(mode=os.P_NOWAIT)  # ASYNC220
    os.spawnl(mode=P_NOWAIT)  # ASYNC220
```
likely benign LLM, confidence 0.90 Ruff flake8-async test fixture with os.spawnl call used to test ASYNC220 detection.
Reasoning
Same linter test fixture; the os.spawnl calls exist to exercise the ASYNC220 rule and are never meant to spawn real processes in production.
info ~~critical~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC22x.py:81:5

`os.spawnl` with a non-literal binary path — runtime-determined process spawn (ast pass, confidence 0.85)
```
    # if it is P_WAIT, ASYNC221
    os.spawnl(P_WAIT)  # ASYNC221
    os.spawnl(mode=os.P_WAIT)  # ASYNC221
    os.spawnl(mode=P_WAIT)  # ASYNC221
```
likely benign LLM, confidence 0.90 Ruff test fixture calling os.spawnl with P_WAIT for ASYNC221 rule coverage.
Reasoning
Linter test fixture exercising the ASYNC221 rule for os.spawnl with P_WAIT; no malicious behavior.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC22x.py:86:5

`os.spawnl` called with a literal binary path (ast pass, confidence 0.70)
```
    # other weird cases: ASYNC220
    os.spawnl(0)  # ASYNC220
    os.spawnl(1)  # ASYNC220
    os.spawnl(foo())  # ASYNC220
```
likely benign LLM, confidence 0.88 Ruff test fixture with os.spawnl calls using literal and function-call arguments.
Reasoning
Test fixture with literal and call arguments to os.spawnl to exercise rule ASYNC220; the warn severity reflects the literal-path pattern, not a threat.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC22x.py:87:5

`os.spawnl` called with a literal binary path (ast pass, confidence 0.70)
```
    os.spawnl(0)  # ASYNC220
    os.spawnl(1)  # ASYNC220
    os.spawnl(foo())  # ASYNC220
```
likely benign LLM, confidence 0.88 Ruff test fixture calling os.spawnl with literal integer argument.
Reasoning
Same test fixture for ASYNC220 rule coverage; no real process spawning intent.
info ~~critical~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_async/ASYNC22x.py:88:5

`os.spawnl` with a non-literal binary path — runtime-determined process spawn (ast pass, confidence 0.85)
```
    os.spawnl(1)  # ASYNC220
    os.spawnl(foo())  # ASYNC220

    # ASYNC222
```
likely benign LLM, confidence 0.90 Ruff test fixture calling os.spawnl with a function-call argument for rule testing.
Reasoning
Linter test fixture for the ASYNC220 rule; the call is part of a list of rule examples and is not malicious.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:8:1

`os.system` called with a literal shell command (ast pass, confidence 0.70)
```
# Check all shell functions.
os.system("true")
os.popen("true")
os.popen2("true")
```
likely benign LLM, confidence 0.90 Ruff flake8-bandit fixture calling os.system with a literal 'true' command.
Reasoning
S605 is a bandit-style test fixture enumerating shell-invoking functions with literal commands to verify the rule fires; no real malicious use.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:9:1

`os.popen` called with a literal shell command (ast pass, confidence 0.70)
```
os.system("true")
os.popen("true")
os.popen2("true")
os.popen3("true")
```
likely benign LLM, confidence 0.90 Ruff S605 test fixture calling os.popen with literal 'true'.
Reasoning
Bandit rule test fixture exercising os.popen with a harmless literal command 'true'.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:20:1

`subprocess.getoutput` called with a literal shell command (ast pass, confidence 0.70)
```
commands.getstatusoutput("true")
subprocess.getoutput("true")
subprocess.getstatusoutput("true")
```
likely benign LLM, confidence 0.90 Ruff S605 test fixture calling subprocess.getoutput with literal 'true'.
Reasoning
Test fixture for S605 covering subprocess.getoutput with harmless 'true' literal; no malicious payload.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:21:1

`subprocess.getstatusoutput` called with a literal shell command (ast pass, confidence 0.70)
```
subprocess.getoutput("true")
subprocess.getstatusoutput("true")
```
likely benign LLM, confidence 0.90 Ruff S605 test fixture calling subprocess.getstatusoutput with literal 'true'.
Reasoning
Same S605 test fixture pattern; literal harmless command used to verify detection.
info ~~critical~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:26:1

`os.system` called on a non-literal command — runtime-determined shell invocation (ast pass, confidence 0.85)
```
var_string = "true"
os.system(var_string)
os.system([var_string])
os.system([var_string, ""])
```
likely benign LLM, confidence 0.88 Ruff S605 test fixture calling os.system with a variable holding 'true'.
Reasoning
Test fixture for the non-literal os.system case; the variable is set to the harmless 'true' just above, so no real risk, though the pattern itself is what the rule targets.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:27:1

`os.system` called with a literal shell command (ast pass, confidence 0.70)
```
os.system(var_string)
os.system([var_string])
os.system([var_string, ""])
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising os.system calls for rule S605.
Reasoning
This is a test fixture for ruff's flake8-bandit S605 rule, which checks os.system calls. The snippet is an ordinary os.system call on a variable, and the file lives in a linter's test resources, so it is a deliberate rule example rather than malicious code.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S605.py:28:1

`os.system` called with a literal shell command (ast pass, confidence 0.70)
```
os.system([var_string])
os.system([var_string, ""])
```
likely benign LLM, confidence 0.95 Ruff linter test fixture with os.system list-argument calls.
Reasoning
Same ruff test fixture for the S605 bandit rule; the os.system calls take list arguments and are only used to test the linter's detection logic.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:12:1

`os.spawnl` called with a literal binary path (ast pass, confidence 0.70)
```
os.execvpe("true")
os.spawnl("true")
os.spawnle("true")
os.spawnlp("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising os.spawn/exec calls with literal paths.
Reasoning
A ruff test fixture for the S606 rule covering os.spawn-family calls with literal paths like "true". The calls are harmless no-op binaries used as test inputs in a linter's resources.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:13:1

`os.spawnle` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnl("true")
os.spawnle("true")
os.spawnlp("true")
os.spawnlpe("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising os.spawnle with a literal path.
Reasoning
Part of the ruff S606 test fixture; the spawn calls invoke the harmless "true" binary and exist only to exercise the rule's detection.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:14:1

`os.spawnlp` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnle("true")
os.spawnlp("true")
os.spawnlpe("true")
os.spawnv("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising os.spawnlp with a literal path.
Reasoning
Ruff test fixture for S606 using harmless "true" binary arguments; no malicious intent is evident in the test resource context.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:15:1

`os.spawnlpe` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnlp("true")
os.spawnlpe("true")
os.spawnv("true")
os.spawnve("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising os.spawnlpe with a literal path.
Reasoning
Ruff S606 rule test fixture; the spawn call targets the benign "true" command purely for linter testing.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:16:1

`os.spawnv` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnlpe("true")
os.spawnv("true")
os.spawnve("true")
os.spawnvp("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising os.spawnv with a literal path.
Reasoning
Ruff S606 test fixture using the harmless "true" binary; this is a rule-test input, not a dropper or obfuscated payload.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:17:1

`os.spawnve` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnv("true")
os.spawnve("true")
os.spawnvp("true")
os.spawnvpe("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising os.spawnve with a literal path.
Reasoning
Part of the ruff S606 test resource; the call uses the innocuous "true" command for detection testing only.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:18:1

`os.spawnvp` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnve("true")
os.spawnvp("true")
os.spawnvpe("true")
os.startfile("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising os.spawnvp with a literal path.
Reasoning
Ruff S606 test fixture with harmless literal "true" arguments; no real-world malicious behaviour is present.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S606.py:19:1

`os.spawnvpe` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnvp("true")
os.spawnvpe("true")
os.startfile("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising os.spawnvpe with a literal path.
Reasoning
Ruff S606 rule test input calling the benign "true" binary; the file is a linter test resource.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:9:1

`os.system` called with a literal shell command (ast pass, confidence 0.70)
```
subprocess.run("true")
os.system("true")
os.popen("true")
os.popen2("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising subprocess and os shell calls with literal commands.
Reasoning
Ruff S607 test fixture in linter resources. The subprocess and os calls use the harmless "true" command purely to exercise partial-path and shell detection rules.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:10:1

`os.popen` called with a literal shell command (ast pass, confidence 0.70)
```
os.system("true")
os.popen("true")
os.popen2("true")
os.popen3("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising os.popen calls with literal commands.
Reasoning
Same ruff S607 test fixture; os.popen with the harmless "true" command is a rule-test input and not malicious.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:29:1

`os.spawnl` called with a literal binary path (ast pass, confidence 0.70)
```
os.execvpe("true")
os.spawnl("true")
os.spawnle("true")
os.spawnlp("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising os.spawnl with a literal path.
Reasoning
Ruff S607 test resource using harmless "true" binary arguments for spawn-family detection; this is test data, not a payload.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:30:1

`os.spawnle` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnl("true")
os.spawnle("true")
os.spawnlp("true")
os.spawnlpe("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising os.spawnle with a literal path.
Reasoning
Ruff S607 test fixture with harmless "true" command arguments; it exists to verify the linter rule and carries no malicious intent.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:31:1

`os.spawnlp` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnle("true")
os.spawnlp("true")
os.spawnlpe("true")
os.spawnv("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture exercising os.spawn* calls with literal binary paths.
Reasoning
This is a test fixture for ruff's flake8-bandit S607 rule, which flags os.spawn* calls with literal paths. The code is a list of literal calls with no obfuscation, decoding, or attacker-controlled input, and the file sits in the linter's own test tree.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:32:1

`os.spawnlpe` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnlp("true")
os.spawnlpe("true")
os.spawnv("true")
os.spawnve("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture with literal os.spawnlpe calls.
Reasoning
Same fixture file for the S607 rule. The literal os.spawnlpe calls are expected test cases for the rule's detection logic, not malicious execution.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:33:1

`os.spawnv` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnlpe("true")
os.spawnv("true")
os.spawnve("true")
os.spawnvp("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture with a literal os.spawnv call.
Reasoning
Same S607 test fixture. The literal os.spawnv call is a deliberate rule trigger in a regression test file.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:34:1

`os.spawnve` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnv("true")
os.spawnve("true")
os.spawnvp("true")
os.spawnvpe("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture with literal os.spawnve calls.
Reasoning
Same S607 test fixture containing literal os.spawnve calls used to test the rule. No dropper or encoded payload is present.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:35:1

`os.spawnvp` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnve("true")
os.spawnvp("true")
os.spawnvpe("true")
os.startfile("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture with literal os.spawnvp and os.startfile calls.
Reasoning
Same S607 test fixture. The os.startfile and os.spawnvp calls are literal test inputs for the linter rule.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:36:1

`os.spawnvpe` called with a literal binary path (ast pass, confidence 0.70)
```
os.spawnvp("true")
os.spawnvpe("true")
os.startfile("true")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture with a literal os.spawnvpe call.
Reasoning
Same S607 test fixture. The literal os.spawnvpe call is a standard rule-trigger case in the linter's own tests.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:40:1

`os.system` called with a literal shell command (ast pass, confidence 0.70)
```
# Check it does not fail for full paths.
os.system("/bin/ls")
os.system("./bin/ls")
os.system(["/bin/ls"])
```
likely benign LLM, confidence 0.95 Ruff linter test fixture with literal os.system calls to /bin/ls.
Reasoning
Same S607 fixture. os.system calls with literal paths like /bin/ls are the rule's test cases, with a comment noting the check is for full paths. Nothing is obfuscated or attacker-driven.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:41:1

`os.system` called with a literal shell command (ast pass, confidence 0.70)
```
os.system("/bin/ls")
os.system("./bin/ls")
os.system(["/bin/ls"])
os.system(["/bin/ls", "/tmp"])
```
likely benign LLM, confidence 0.95 Ruff linter test fixture with literal os.system calls.
Reasoning
Same S607 fixture with literal os.system calls, including a list argument. These are deliberate test inputs for the rule.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:42:1

`os.system` called with a literal shell command (ast pass, confidence 0.70)
```
os.system("./bin/ls")
os.system(["/bin/ls"])
os.system(["/bin/ls", "/tmp"])
os.system(r"C:\\bin\ls")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture with literal os.system calls and a Windows path.
Reasoning
Same S607 fixture with literal os.system calls, including a raw-string Windows path. These are standard rule-trigger cases in a test file.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:43:1

`os.system` called with a literal shell command (ast pass, confidence 0.70)
```
os.system(["/bin/ls"])
os.system(["/bin/ls", "/tmp"])
os.system(r"C:\\bin\ls")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture with literal os.system calls and a regression comment.
Reasoning
Same S607 fixture. The literal os.system calls are test inputs for the rule, and a regression reference to a ruff GitHub issue appears nearby.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S607.py:44:1

`os.system` called with a literal shell command (ast pass, confidence 0.70)
```
os.system(["/bin/ls", "/tmp"])
os.system(r"C:\\bin\ls")

# Regression for https://github.com/astral-sh/ruff/issues/24075
```
likely benign LLM, confidence 0.95 Ruff linter test fixture with a literal os.system call and a regression reference.
Reasoning
Same S607 fixture. The literal os.system call is a deliberate test case, and the trailing comment references a ruff issue regression.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S609.py:4:1

`os.popen` called with a literal shell command (ast pass, confidence 0.70)
```
os.popen("chmod +w foo*")
subprocess.Popen("/bin/chown root: *", shell=True)
subprocess.Popen(["/usr/local/bin/rsync", "*", "some_where:"], shell=True)
```
likely benign LLM, confidence 0.95 Ruff linter test fixture with literal os.popen and subprocess commands containing wildcards.
Reasoning
Test fixture for ruff's S609 rule, which flags wildcard usage in shell commands. The os.popen and subprocess calls with literal strings are intentional test cases, not obfuscated or malicious code.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S609.py:5:1

`subprocess.Popen` called with `shell=True` and a literal command (ast pass, confidence 0.70)
```
os.popen("chmod +w foo*")
subprocess.Popen("/bin/chown root: *", shell=True)
subprocess.Popen(["/usr/local/bin/rsync", "*", "some_where:"], shell=True)
subprocess.Popen("/usr/local/bin/rsync * no_injection_here:")
```
likely benign LLM, confidence 0.95 Ruff linter test fixture with subprocess.Popen shell=True calls using literal commands.
Reasoning
Same S609 fixture. The subprocess.Popen calls with shell=True and literal commands are deliberate examples of the pattern the rule detects, in a linter test tree.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S609.py:6:1

`subprocess.Popen` called with `shell=True` and a literal command (ast pass, confidence 0.70)
```
subprocess.Popen("/bin/chown root: *", shell=True)
subprocess.Popen(["/usr/local/bin/rsync", "*", "some_where:"], shell=True)
subprocess.Popen("/usr/local/bin/rsync * no_injection_here:")
os.system("tar cf foo.tar bar/*")
```
likely benign LLM, confidence 0.90 Test-fixture subprocess.Popen calls with shell=True and literal commands.
Reasoning
This is a ruff linter test fixture for the S609 rule, which exists to flag shell=True calls. The literal commands are inert examples used to exercise the rule, not a payload.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/flake8_bandit/S609.py:8:1

`os.system` called with a literal shell command (ast pass, confidence 0.70)
```
subprocess.Popen("/usr/local/bin/rsync * no_injection_here:")
os.system("tar cf foo.tar bar/*")

subprocess.Popen(["chmod", "+w", "*.py"], shell={**{}})
```
likely benign LLM, confidence 0.90 Test-fixture os.system call with a literal shell command.
Reasoning
The same S609 test fixture. The os.system call has a fixed literal command with no external input, and the file exists to test the linter rule.
info identifier-low-length crates/ruff_linter/resources/test/fixtures/flake8_bugbear/B005.py:1:1

28 of 65 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/flake8_comprehensions/C403.py:1:1

25 of 61 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/flake8_comprehensions/C408.py:1:1

18 of 37 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/flake8_implicit_str_concat/ISC.py:1:1

21 of 40 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/flake8_implicit_str_concat/ISC.py:6:1

file mixes tab and space indentation (3 tab-indented and 68 space-indented lines) (raw pass, confidence 0.40)
```
_ = "abc" \
    "def"

_ = (
```
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/flake8_return/RET505.py:5:1

file mixes tab and space indentation (4 tab-indented and 161 space-indented lines) (raw pass, confidence 0.40)
```
def foo2(x, y, w, z):
    if x:  # [no-else-return]
        a = 1
        return y
```
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM108.py:3:1

file mixes tab and space indentation (4 tab-indented and 69 space-indented lines) (raw pass, confidence 0.40)
```
if a:
    b = c
else:
    b = d
```
info identifier-low-length crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM109.py:1:1

mean non-conventional identifier length 1.52 over 63 names (token pass, confidence 0.50)
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM110.py:162:26

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # SIM110
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ":
        if x.isdigit():
            return True
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM110.py:162:41

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # SIM110
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ":
        if x.isdigit():
            return True
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM110.py:162:56

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # SIM110
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ":
        if x.isdigit():
            return True
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM110.py:162:71

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # SIM110
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ":
        if x.isdigit():
            return True
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM110.py:170:26

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # OK (too long)
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9":
        if x.isdigit():
            return True
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM110.py:170:41

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # OK (too long)
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9":
        if x.isdigit():
            return True
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM110.py:170:56

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # OK (too long)
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9":
        if x.isdigit():
            return True
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM110.py:170:71

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # OK (too long)
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9":
        if x.isdigit():
            return True
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM111.py:178:26

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # SIM111
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9":
        if x.isdigit():
            return False
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM111.py:178:41

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # SIM111
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9":
        if x.isdigit():
            return False
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM111.py:178:56

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # SIM111
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9":
        if x.isdigit():
            return False
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM111.py:178:71

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # SIM111
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9":
        if x.isdigit():
            return False
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM111.py:186:26

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # OK (too long)
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß90":
        if x.isdigit():
            return False
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM111.py:186:41

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # OK (too long)
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß90":
        if x.isdigit():
            return False
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM111.py:186:56

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # OK (too long)
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß90":
        if x.isdigit():
            return False
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM111.py:186:71

identifier `ℝ9012ß90` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    # OK (too long)
    for x in "012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß90":
        if x.isdigit():
            return False
```
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM114.py:3:1

file mixes tab and space indentation (1 tab-indented and 85 space-indented lines) (raw pass, confidence 0.40)
```
if a:
    b
elif c:
    b
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM117.py:95:19

identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
# SIM117 (auto-fixable)
with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as a:
    with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
        print("hello")
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM117.py:95:34

identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
# SIM117 (auto-fixable)
with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as a:
    with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
        print("hello")
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM117.py:96:23

identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as a:
    with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
        print("hello")
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM117.py:96:38

identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as a:
    with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
        print("hello")
```

info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM117.py:100:19

identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

# SIM117 (not auto-fixable too long)
with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ890") as a:
    with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
        print("hello")

info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM117.py:100:34

identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

# SIM117 (not auto-fixable too long)
with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ890") as a:
    with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
        print("hello")

info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM117.py:101:23

identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ890") as a:
    with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
        print("hello")
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM117.py:101:38

identifier `ℝ8901ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
with A("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ890") as a:
    with B("01ß9💣2ℝ8901ß9💣2ℝ8901ß9💣2ℝ89") as b:
        print("hello")
```
info identifier-low-length crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM212.py:1:1

mean non-conventional identifier length 1.81 over 27 names (token pass, confidence 0.50)
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM401.py:43:33

identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
else:
    vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789"

# SIM401
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM401.py:43:48

identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
else:
    vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789"

# SIM401
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM401.py:43:63

identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
else:
    vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789"

# SIM401
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM401.py:43:78

identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
else:
    vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789"

# SIM401
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM401.py:62:33

identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
else:
    vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß"

# OK (false negative)
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM401.py:62:48

identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
else:
    vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß"

# OK (false negative)
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM401.py:62:63

identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
else:
    vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß"

# OK (false negative)
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM401.py:62:78

identifier `ℝ6789ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
else:
    vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß"

# OK (false negative)
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/flake8_simplify/SIM401.py:62:93

identifier `ℝ6789ß` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
else:
    vars[idx] = "defaultß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß9💣2ℝ6789ß"

# OK (false negative)
```
info identifier-low-length crates/ruff_linter/resources/test/fixtures/flake8_use_pathlib/PTH210_1.py:1:1

78 of 195 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/isort/comments.py:1:1

20 of 40 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)

info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/fit_line_length_comment.py:6:31

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

# The next import fits on one line.
from f import g  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ
# The next import doesn't fit on one line.

info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/fit_line_length_comment.py:6:46

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

# The next import fits on one line.
from f import g  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ
# The next import doesn't fit on one line.

info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/fit_line_length_comment.py:6:61

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

# The next import fits on one line.
from f import g  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ
# The next import doesn't fit on one line.

info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/fit_line_length_comment.py:6:76

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

# The next import fits on one line.
from f import g  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ
# The next import doesn't fit on one line.

info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/fit_line_length_comment.py:6:91

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

# The next import fits on one line.
from f import g  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ
# The next import doesn't fit on one line.

info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/fit_line_length_comment.py:6:106

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)

# The next import fits on one line.
from f import g  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ
# The next import doesn't fit on one line.

info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/fit_line_length_comment.py:8:31

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
# The next import doesn't fit on one line.
from h import i  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/fit_line_length_comment.py:8:46

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
# The next import doesn't fit on one line.
from h import i  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/fit_line_length_comment.py:8:61

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
# The next import doesn't fit on one line.
from h import i  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/fit_line_length_comment.py:8:76

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
# The next import doesn't fit on one line.
from h import i  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/fit_line_length_comment.py:8:91

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
# The next import doesn't fit on one line.
from h import i  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/fit_line_length_comment.py:8:106

identifier `ℝ9012ß9` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
# The next import doesn't fit on one line.
from h import i  # 012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9012ß9💣2ℝ9
```
info ~~warn~~ → info by review unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/length_sort_non_ascii_members.py:7:5

identifier `μεδιυυυυυμ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)
```
    looooooooooooooong,
    μεδιυυυυυμ,
    short,
    mediuuuuuum,
```
likely benign LLM, confidence 0.90 Identifier mixing Greek and Latin letters in an isort sorting fixture.
Reasoning
This is an isort test fixture for sorting non-ASCII member names. Mixing Greek and Latin letters is deliberate test input for sort ordering, not obfuscation.
info ~~warn~~ → info by review unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/length_sort_non_ascii_modules.py:8:8

identifier `μεδιυυυυυμ` mixes scripts: Latin + Greek (raw pass, confidence 0.80)
```
import λοοοοοοοοοοοοοονγ
import μεδιυυυυυμ
import looooooooooooooong
```
likely benign LLM, confidence 0.90 Module import name mixing Greek and Latin letters in an isort fixture.
Reasoning
Same isort non-ASCII sorting fixture. The mixed-script module name is intentional test data for module-length sorting.
info identifier-low-length crates/ruff_linter/resources/test/fixtures/isort/sort_similar_imports.py:1:1

40 of 100 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/isort/split.py:1:1

14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info ~~warn~~ → info by review unicode-mixed-script crates/ruff_linter/resources/test/fixtures/isort/unicode.py:4:17

identifier `CƐgHHHhIILlNZΩZKÅBCeEFio` mixes scripts: Latin + Greek (raw pass, confidence 0.80)
```
import numpy as ℂℇℊℋℌℍℎℐℑℒℓℕℤΩℨKÅℬℭℯℰℱℹℴ
import numpy as CƐgHHHhIILlNZΩZKÅBCeEFio

h = 2 * π * ℏ
```
likely benign LLM, confidence 0.90 Unicode identifier with mixed Latin and Greek letters in an isort test fixture.
Reasoning
The isort unicode fixture deliberately uses Unicode letterlike symbols and mixed scripts to test import sorting. It is not a runtime risk.
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pycodestyle/E101.py:2:1

file mixes tab and space indentation (2 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)
```
def func_all_spaces():
    # No error
    print("spaces")
```
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pycodestyle/E11.py:3:1

file mixes tab and space indentation (1 tab-indented and 23 space-indented lines) (raw pass, confidence 0.40)
```
if x > 2:
  print(x)
#: E111 E117
if True:
```
info identifier-low-length crates/ruff_linter/resources/test/fixtures/pycodestyle/E22.py:1:1

63 of 154 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pycodestyle/E27.py:9:1

file mixes tab and space indentation (1 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)
```
if   1:
    pass
#: E273
True and		False
```
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pycodestyle/E30.py:10:1

file mixes tab and space indentation (8 tab-indented and 287 space-indented lines) (raw pass, confidence 0.40)
```
class Class:
    pass
# end
```
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pycodestyle/E501_2.py:3:1

file mixes tab and space indentation (11 tab-indented and 1 space-indented lines) (raw pass, confidence 0.40)
```
# aaaaa
    # a
	# a
	# aa
```
info identifier-low-length crates/ruff_linter/resources/test/fixtures/pycodestyle/E741.py:1:1

40 of 98 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/pycodestyle/E741.pyi:1:1

40 of 98 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pycodestyle/W19.py:1:1

file mixes tab and space indentation (44 tab-indented and 24 space-indented lines) (raw pass, confidence 0.40)
```
	'''File starts with a tab
	multiline string with tab in it'''
```
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pycodestyle/W29.py:8:1

file mixes tab and space indentation (1 tab-indented and 3 space-indented lines) (raw pass, confidence 0.40)
```
    
    bang = 12
#: W291:2:35
'''multiline
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/pycodestyle/W505_utf_8.py:2:31

identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
#!/usr/bin/env python3
"""Here's a top-level ß9💣2ℝing that's over theß9💣2ℝ."""
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/pycodestyle/W505_utf_8.py:6:25

identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
def f1():
    """Here's a ß9💣2ℝing that's also over theß9💣2ℝ."""

    x = 1  # Here's a comment that's over theß9💣2ℝ, but it's not standalone.
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/pycodestyle/W505_utf_8.py:15:79

identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    print("Here's a string that's over theß9💣2ℝ, but it's not a ß9💣2ℝing.")
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/pycodestyle/W505_utf_8.py:18:36

identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
"This is also considered a ß9💣2ℝing, and is over theß9💣2ℝ."
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/pycodestyle/W505_utf_8.py:22:36

identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
def f2():
    """Here's a multi-line ß9💣2ℝing.

    It's over theß9💣2ℝ on this line, which isn't the first line in the ß9💣2ℝing.
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/pycodestyle/W505_utf_8.py:24:86

identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    It's over theß9💣2ℝ on this line, which isn't the first line in the ß9💣2ℝing.
    """
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/pycodestyle/W505_utf_8.py:29:36

identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
def f3():
    """Here's a multi-line ß9💣2ℝing.

    It's over theß9💣2ℝ on this line, which isn't the first line in the ß9💣2ℝing."""
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/pycodestyle/W505_utf_8.py:31:86

identifier `ℝing` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
    It's over theß9💣2ℝ on this line, which isn't the first line in the ß9💣2ℝing."""
```
info ~~warn~~ → info by review whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pydocstyle/D.py:723:4

invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)
```
   ⟨U+00A0⟩ ⟨U+00A0⟩ Returns:
    """
```
likely benign LLM, confidence 0.85 Non-breaking space in the indentation of a docstring in a pydocstyle fixture.
Reasoning
A non-breaking space in a docstring indent is a whitespace-quirk test input for pydocstyle. It sits in a docstring and cannot execute.
info ~~warn~~ → info by review whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pydocstyle/D208.py:9:9

invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)
```
            Args:
        ⟨U+00A0⟩ ⟨U+00A0⟩ Returns:
            """
```
likely benign LLM, confidence 0.85 Non-breaking space in a docstring indentation in a D208 fixture.
Reasoning
The D208 fixture tests over-indented docstring handling, and the non-breaking space is part of that test input. The text is inside a docstring.
info ~~warn~~ → info by review whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pydocstyle/D208.py:15:1

invisible whitespace U+3000 in indentation (raw pass, confidence 0.80)
```
    """
⟨U+3000⟩⟨U+3000⟩⟨U+3000⟩参数含义：precision:精确到小数点后几位
    """
```
likely benign LLM, confidence 0.85 Ideographic space in the indentation of a Chinese docstring in a D208 fixture.
Reasoning
The ideographic space is inside a Chinese docstring in a D208 indentation fixture. It is test data for docstring handling, with no executable effect.
info identifier-low-length crates/ruff_linter/resources/test/fixtures/pyflakes/F602.py:1:1

mean non-conventional identifier length 1.00 over 29 names (token pass, confidence 0.50)
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pyflakes/F722.py:2:1

file mixes tab and space indentation (4 tab-indented and 7 space-indented lines) (raw pass, confidence 0.40)
```
class A:
    pass
```

info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pyflakes/F811_36.py:5:1

file mixes tab and space indentation (2 tab-indented and 10 space-indented lines) (raw pass, confidence 0.40)

if TYPE_CHECKING:
    # See: https://github.com/astral-sh/ruff/issues/22554
    # should detect -------------------------vvvvvvvvvvvvv
    from faststream._internal.broker import BrokerUsecase

info identifier-low-length crates/ruff_linter/resources/test/fixtures/pyflakes/F821_17.py:1:1

112 of 270 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
info ~~critical~~ → info by review unicode-bidi crates/ruff_linter/resources/test/fixtures/pylint/bidirectional_unicode.py:2:16

U+202C POP DIRECTIONAL FORMATTING in source (raw pass, confidence 0.98)
```
# E2502
print("שלום⟨U+202C⟩")

# E2502
```
likely benign LLM, confidence 0.85 Pop-directional-formatting control character in a pylint E2502 test fixture.
Reasoning
This file is a pylint E2502 test fixture for bidirectional Unicode. The control character is deliberate test content for the rule. Its location in a fixture, not in product code, makes it benign.
info ~~critical~~ → info by review unicode-bidi crates/ruff_linter/resources/test/fixtures/pylint/bidirectional_unicode.py:11:25

U+202E RIGHT-TO-LEFT OVERRIDE in source (raw pass, confidence 0.98)
```
# E2502
if access_level != "none⟨U+202E⟩⟨U+2066⟩":  # Check if admin ⟨U+2069⟩⟨U+2066⟩' and access_level != 'user
    print("You are an admin.")
```
likely benign LLM, confidence 0.85 Right-to-left override character in a pylint E2502 test fixture.
Reasoning
The file is a deliberate Trojan Source test fixture for E2502. The right-to-left override is test input meant to trigger the rule, and it is not hidden in real application logic.
info ~~critical~~ → info by review unicode-bidi crates/ruff_linter/resources/test/fixtures/pylint/bidirectional_unicode.py:11:28

U+2066 LEFT-TO-RIGHT ISOLATE in source (raw pass, confidence 0.98)
```
# E2502
if access_level != "none⟨U+202E⟩⟨U+2066⟩":  # Check if admin ⟨U+2069⟩⟨U+2066⟩' and access_level != 'user
    print("You are an admin.")
```
likely benign LLM, confidence 0.85 Left-to-right isolate character in a pylint E2502 test fixture.
Reasoning
Same E2502 bidi test fixture. The isolate character is intentional test content for the rule, not a live attack in product code.
info ~~critical~~ → info by review unicode-bidi crates/ruff_linter/resources/test/fixtures/pylint/bidirectional_unicode.py:11:52

U+2069 POP DIRECTIONAL ISOLATE in source (raw pass, confidence 0.98)
```
# E2502
if access_level != "none⟨U+202E⟩⟨U+2066⟩":  # Check if admin ⟨U+2069⟩⟨U+2066⟩' and access_level != 'user
    print("You are an admin.")
```
likely benign LLM, confidence 0.85 Pop-directional-isolate character in a pylint E2502 test fixture.
Reasoning
Same E2502 bidi test fixture. The pop-isolate character is deliberate test input for the bidi rule.
info ~~critical~~ → info by review unicode-bidi crates/ruff_linter/resources/test/fixtures/pylint/bidirectional_unicode.py:11:55

U+2066 LEFT-TO-RIGHT ISOLATE in source (raw pass, confidence 0.98)
```
# E2502
if access_level != "none⟨U+202E⟩⟨U+2066⟩":  # Check if admin ⟨U+2069⟩⟨U+2066⟩' and access_level != 'user
    print("You are an admin.")
```
likely benign LLM, confidence 0.85 Second left-to-right isolate character in a pylint E2502 test fixture.
Reasoning
Same E2502 bidi test fixture. The repeated isolate character is intentional test content that exercises the rule.
info ~~critical~~ → info by review unicode-bidi crates/ruff_linter/resources/test/fixtures/pylint/bidirectional_unicode.py:17:46

U+2067 RIGHT-TO-LEFT ISOLATE in source (raw pass, confidence 0.98)
```
def subtract_funds(account: str, amount: int):
    """Subtract funds from bank account then ⟨U+2067⟩"""
    return
    bank[account] -= amount
```
likely benign LLM, confidence 0.90 Test fixture containing a U+2067 bidi isolate character in a docstring to exercise the unicode-bidi rule.
Reasoning
This is a deliberate test fixture for ruff's bidirectional unicode rule. The RTL isolate character is inside a docstring, and it is the exact thing the linter is designed to detect. Within a ruff test corpus it is intentional, not an attack payload.
info identifier-low-length crates/ruff_linter/resources/test/fixtures/pylint/boolean_chained_comparison.py:1:1

171 of 345 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pylint/boolean_chained_comparison.py:9:1

file mixes tab and space indentation (1 tab-indented and 23 space-indented lines) (raw pass, confidence 0.40)
```
if a < b and b < c:  # [boolean-chained-comparison]
    pass

a = int(input())
```
info identifier-low-length crates/ruff_linter/resources/test/fixtures/pylint/duplicate_bases.py:1:1

28 of 54 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)
info ~~warn~~ → info by review unicode-homoglyph crates/ruff_linter/resources/test/fixtures/pylint/empty_comment.py:57:1

identifier `α` contains homoglyph candidates: α (03B1)→a (raw pass, confidence 0.70)
```
α = 1
α#
```
likely benign LLM, confidence 0.85 Fixture assigning a Greek alpha identifier next to an empty comment, used to test lint handling.
Reasoning
This is a ruff pylint fixture testing empty-comment handling. The Greek alpha identifier is a deliberate homoglyph test case in a linter corpus, and the code is trivial with no execution or exfiltration.
info ~~warn~~ → info by review unicode-homoglyph crates/ruff_linter/resources/test/fixtures/pylint/empty_comment.py:58:1

identifier `α` contains homoglyph candidates: α (03B1)→a (raw pass, confidence 0.70)
```
α = 1
α#
```
likely benign LLM, confidence 0.85 Second Greek alpha homoglyph identifier in the same empty-comment test fixture.
Reasoning
Same fixture as the previous finding. The homoglyph identifier is an intentional test input in ruff's test suite and performs no malicious action.
info identifier-low-length crates/ruff_linter/resources/test/fixtures/pylint/global_variable_not_assigned.py:1:1

21 of 39 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/pylint/repeated_keyword_argument.py:1:1

30 of 49 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/pylint/subprocess_run_without_check.py:5:1

`subprocess.run` called with `shell=True` and a literal command (ast pass, confidence 0.70)
```
subprocess.run("ls")
subprocess.run("ls", shell=True)
subprocess.run(
    ["ls"],
```
likely benign LLM, confidence 0.90 Linter fixture calling subprocess.run with shell=True and the literal command 'ls'.
Reasoning
This is a ruff test fixture for the subprocess-run-without-check rule. The literal command 'ls' with shell=True is a deliberate example of a pattern the linter flags, not a malicious payload.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/pylint/subprocess_run_without_check.py:15:1

`subprocess.run` called with `shell=True` and a literal command (ast pass, confidence 0.70)
```
subprocess.run("ls", check=False)
subprocess.run("ls", shell=True, check=True)
subprocess.run("ls", shell=True, check=False)
foo.run("ls")  # Not a subprocess.run call.
```
likely benign LLM, confidence 0.90 Fixture listing subprocess.run variants with shell=True and a literal 'ls' command.
Reasoning
Test fixture exercising various subprocess.run argument combinations, with a literal 'ls' command. It is benign linter test data.
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/pylint/subprocess_run_without_check.py:16:1

`subprocess.run` called with `shell=True` and a literal command (ast pass, confidence 0.70)
```
subprocess.run("ls", shell=True, check=True)
subprocess.run("ls", shell=True, check=False)
foo.run("ls")  # Not a subprocess.run call.
subprocess.bar("ls")  # Not a subprocess.run call.
```
likely benign LLM, confidence 0.90 Fixture with subprocess.run shell=True and a literal 'ls' command, used to test check-argument linting.
Reasoning
Same fixture as the previous finding, with the same benign literal 'ls' command and no attacker-controlled input.
info identifier-low-length crates/ruff_linter/resources/test/fixtures/pylint/too_many_arguments.py:1:1

90 of 151 non-conventional identifiers are single-character (60%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/pylint/too_many_boolean_expressions.py:1:1

267 of 619 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/pylint/too_many_positional_arguments.py:1:1

85 of 138 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/pylint/useless_else_on_loop.py:121:14

`open(__file__)` — file reads its own source, common pattern for extracting payloads hidden in comments (ast pass, confidence 0.85)
```
    for name in ["demo"]:
        with open(__file__) as f:
            if name in f.read():
                break
```
likely benign LLM, confidence 0.85 Test fixture reading __file__ to check for a marker string inside a loop.
Reasoning
The code opens its own source file to search for a string, a benign self-inspection pattern. It is a loop-else test fixture, and the 'payload extraction' message is a heuristic overreach with no decoding or execution.
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pyupgrade/UP012.py:13:1

file mixes tab and space indentation (1 tab-indented and 11 space-indented lines) (raw pass, confidence 0.40)
```
""".encode(
    "utf-8"
)
(
```
info identifier-low-length crates/ruff_linter/resources/test/fixtures/pyupgrade/UP037_2.pyi:1:1

mean non-conventional identifier length 1.88 over 32 names (token pass, confidence 0.50)
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/pyupgrade/UP037_2.pyi:7:1

file mixes tab and space indentation (3 tab-indented and 13 space-indented lines) (raw pass, confidence 0.40)
```
def f(a: Foo['''Bar[
    Multi |
    Line]''']): ...
```
info identifier-low-length crates/ruff_linter/resources/test/fixtures/refurb/FURB145.py:1:1

mean non-conventional identifier length 1.19 over 27 names (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/refurb/FURB152.py:1:1

mean non-conventional identifier length 1.00 over 28 names (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/refurb/FURB187.py:1:1

48 of 75 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/ruff/RUF021.py:1:1

150 of 284 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/ruff/RUF028.py:103:12

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
def test_eval(test_input, expected):
    assert eval(test_input) == expected
```
likely benign LLM, confidence 0.90 Test helper that evaluates a test input string with eval to compare against an expected value.
Reasoning
This is a ruff test fixture for RUF028 that deliberately calls eval in a test helper. The input comes from test parameters, so it is not an attack, but the code is an eval on a non-literal in a test context.
info identifier-low-length crates/ruff_linter/resources/test/fixtures/ruff/RUF031.py:1:1

24 of 52 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/ruff/RUF031_prefer_parens.py:1:1

24 of 52 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/ruff/RUF051.py:1:1

mean non-conventional identifier length 1.99 over 223 names (token pass, confidence 0.50)
info whitespace-anomaly crates/ruff_linter/resources/test/fixtures/ruff/RUF054.py:8:1

file mixes tab and space indentation (3 tab-indented and 4 space-indented lines) (raw pass, confidence 0.40)
```
 ⟨U+000C⟩

		⟨U+000C⟩
```
info ~~warn~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/ruff/RUF100_0.py:113:5

`eval` called on a non-literal expression (ast pass, confidence 0.70)
```
    # Disabled - check redirects are reported correctly
    eval(command)  # noqa: PGH001
```
likely benign LLM, confidence 0.90 Fixture calling eval(command) with a noqa directive to test RUF100 handling.
Reasoning
Ruff's noqa-handling test fixture. eval(command) is present to exercise noqa directive parsing, not to run attacker-controlled code.
info ~~critical~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/ruff/RUF100_0.py:128:5

`eval` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)
```
# Allow code redirects
x = eval(command)  # noqa: PGH001, S307
x = eval(command)  # noqa: S307, PGH001, S307, S307, S307
x = eval(command)  # noqa: PGH001, S307, PGH001
```
likely benign LLM, confidence 0.90 Module-level eval(command) line in a RUF100 noqa test fixture.
Reasoning
Module-scope eval in a ruff noqa test fixture, used to test unused and redundant noqa codes. The 'runs on import' severity is accurate for the pattern but the file is a test corpus, not a shipped package.
info ~~critical~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/ruff/RUF100_0.py:129:5

`eval` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)
```
x = eval(command)  # noqa: PGH001, S307
x = eval(command)  # noqa: S307, PGH001, S307, S307, S307
x = eval(command)  # noqa: PGH001, S307, PGH001
x = eval(command)  # noqa: PGH001, S307, PGH001, S307
```
likely benign LLM, confidence 0.90 Another module-level eval(command) line in the noqa test fixture.
Reasoning
Repeated module-level eval lines exist only to test noqa directive deduplication in ruff's test suite. No malicious behaviour is present.
info ~~critical~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/ruff/RUF100_0.py:130:5

`eval` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)
```
x = eval(command)  # noqa: S307, PGH001, S307, S307, S307
x = eval(command)  # noqa: PGH001, S307, PGH001
x = eval(command)  # noqa: PGH001, S307, PGH001, S307
```
likely benign LLM, confidence 0.90 Module-level eval(command) line in the RUF100 noqa test fixture.
Reasoning
Same as the other RUF100 fixture findings: deliberate noqa test input in a linter repository, not a supply-chain payload.
info ~~critical~~ → info by review dynamic-execution crates/ruff_linter/resources/test/fixtures/ruff/RUF100_0.py:131:5

`eval` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)
```
x = eval(command)  # noqa: PGH001, S307, PGH001
x = eval(command)  # noqa: PGH001, S307, PGH001, S307
```
likely benign LLM, confidence 0.90 Test fixture line calling eval(command) to exercise noqa directive parsing.
Reasoning
This is a ruff linter test fixture exercising noqa-comment handling. The eval call is a deliberate lint target with a noqa directive, not a malicious payload. It is in a test fixture, so the scanner flag is an expected false positive.
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:1:6

identifier `𝐁ad` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
x = "𝐁ad string"
y = "−"
```
info unicode-homoglyph crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:12:45

identifier `ρ` contains homoglyph candidates: ρ (03C1)→p (in string/comment) (raw pass, confidence 0.35)
```
def f():
    """Here's a docstring with a greek rho: ρ"""
    # And here's a comment with a greek alpha: ∗
    ...
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:17:6

identifier `𝐁ad` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
x = "𝐁ad string"
x = "−"
```
info unicode-homoglyph crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:26:11

identifier `Bαd` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
# contains ASCII.
x = "βα Bαd"

# The two characters should be flagged here. The first character is a "word"
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:26:11

identifier `Bαd` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
```
# contains ASCII.
x = "βα Bαd"

# The two characters should be flagged here. The first character is a "word"
```
info unicode-homoglyph crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:31:6

identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)
```
# boundary" (whitespace) that it itself ambiguous.
x = "Р⟨U+2000⟩усский"

# Same test cases as above but using f-strings instead:
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:34:7

identifier `𝐁ad` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
# Same test cases as above but using f-strings instead:
x = f"𝐁ad string"
x = f"−"
x = f"Русский"
```
info unicode-homoglyph crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:37:12

identifier `Bαd` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
x = f"Русский"
x = f"βα Bαd"
x = f"Р⟨U+2000⟩усский"
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:37:12

identifier `Bαd` mixes scripts: Latin + Greek (in string/comment) (raw pass, confidence 0.40)
```
x = f"Русский"
x = f"βα Bαd"
x = f"Р⟨U+2000⟩усский"
```
info unicode-homoglyph crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:38:7

identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)
```
x = f"βα Bαd"
x = f"Р⟨U+2000⟩усский"

# Nested f-strings
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:41:7

identifier `𝐁ad` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
# Nested f-strings
x = f"𝐁ad string {f"⟨U+2000⟩{f"Р⟨U+2000⟩усский"}"}"

# Comments inside f-strings
```
info unicode-homoglyph crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:41:30

identifier `Р` contains homoglyph candidates: Р (0420)→P (in string/comment) (raw pass, confidence 0.35)
```
# Nested f-strings
x = f"𝐁ad string {f"⟨U+2000⟩{f"Р⟨U+2000⟩усский"}"}"

# Comments inside f-strings
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:58:6

identifier `𝐁ad` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
# Implicit string concatenation
x = "𝐁ad" f"𝐁ad string"

from typing import Literal
```
info unicode-mixed-script crates/ruff_linter/resources/test/fixtures/ruff/confusables.py:58:16

identifier `𝐁ad` mixes scripts: Other + Latin (in string/comment) (raw pass, confidence 0.40)
```
# Implicit string concatenation
x = "𝐁ad" f"𝐁ad string"

from typing import Literal
```
info identifier-low-length crates/ruff_linter/resources/test/fixtures/semantic_errors/global_parameter.py:1:1

23 of 47 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_linter/resources/test/fixtures/semantic_errors/nonlocal_parameter.py:1:1

26 of 56 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)
info ~~warn~~ → info by review whitespace-anomaly crates/ruff_linter/src/lib.rs:77:9

invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)
```
            Args:
        ⟨U+00A0⟩ ⟨U+00A0⟩ Returns:
            """
"#;
```
likely benign LLM, confidence 0.85 Docstring sample in a Rust raw string containing a non-breaking space in indentation.
Reasoning
Raw-pass whitespace anomaly on a docstring indentation line inside a Rust raw string literal. Non-breaking spaces in embedded Python docstring sample text are a plausible copy artifact and carry no execution risk. Raw pass has higher false-positive rates.

info whitespace-anomaly crates/ruff_linter/src/linter.rs:41:1

file mixes tab and space indentation (58 tab-indented and 965 space-indented lines) (raw pass, confidence 0.40)

pub struct LinterResult {
    /// A collection of diagnostic messages generated by the linter.
    pub diagnostics: Vec<Diagnostic>,
    /// Flag indicating that the parsed source code does not contain any

info unicode-homoglyph crates/ruff_linter/src/locator.rs:78:37

identifier `α` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
    ///
    /// let locator = Locator::new("α");
    ///
    /// assert_eq!(
```

info unicode-homoglyph crates/ruff_linter/src/rules/ruff/mod.rs:426:68

identifier `ρ` contains homoglyph candidates: ρ (03C1)→p (in string/comment) (raw pass, confidence 0.35)

            &settings::LinterSettings {
                allowed_confusables: FxHashSet::from_iter(['−', 'ρ', '∗']),
                ..settings::LinterSettings::for_rules(vec![
                    Rule::AmbiguousUnicodeCharacterString,

info unicode-homoglyph crates/ruff_linter/src/rules/ruff/mod.rs:444:68

identifier `ρ` contains homoglyph candidates: ρ (03C1)→p (in string/comment) (raw pass, confidence 0.35)

                unresolved_target_version: PythonVersion::PY313.into(),
                allowed_confusables: FxHashSet::from_iter(['−', 'ρ', '∗']),
                ..settings::LinterSettings::for_rules(vec![
                    Rule::AmbiguousUnicodeCharacterString,

info unicode-homoglyph crates/ruff_linter/src/rules/ruff/mod.rs:453:68

identifier `ρ` contains homoglyph candidates: ρ (03C1)→p (in string/comment) (raw pass, confidence 0.35)

                unresolved_target_version: PythonVersion::PY314.into(),
                allowed_confusables: FxHashSet::from_iter(['−', 'ρ', '∗']),
                ..settings::LinterSettings::for_rules(vec![
                    Rule::AmbiguousUnicodeCharacterString,

info unicode-homoglyph crates/ruff_linter/src/rules/ruff/mod.rs:470:68

identifier `ρ` contains homoglyph candidates: ρ (03C1)→p (in string/comment) (raw pass, confidence 0.35)

                preview: PreviewMode::Enabled,
                allowed_confusables: FxHashSet::from_iter(['−', 'ρ', '∗']),
                ..settings::LinterSettings::for_rules(vec![
                    Rule::AmbiguousUnicodeCharacterString,

info unicode-homoglyph crates/ruff_linter/src/rules/ruff/rules/ambiguous_unicode_character.rs:37:12

identifier `Ηello` contains homoglyph candidates: Η (0397)→H (in string/comment) (raw pass, confidence 0.35)
```
/// ```python
/// print("Ηello, world!")  # "Η" is the Greek eta (`U+0397`).
/// ```
///
```
info unicode-mixed-script crates/ruff_linter/src/rules/ruff/rules/ambiguous_unicode_character.rs:37:12

identifier `Ηello` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
/// ```python
/// print("Ηello, world!")  # "Η" is the Greek eta (`U+0397`).
/// ```
///
```
info unicode-homoglyph crates/ruff_linter/src/rules/ruff/rules/ambiguous_unicode_character.rs:37:33

identifier `Η` contains homoglyph candidates: Η (0397)→H (in string/comment) (raw pass, confidence 0.35)
```
/// ```python
/// print("Ηello, world!")  # "Η" is the Greek eta (`U+0397`).
/// ```
///
```
info unicode-homoglyph crates/ruff_linter/src/rules/ruff/rules/ambiguous_unicode_character.rs:145:14

identifier `nоqa` contains homoglyph candidates: о (043E)→o (in string/comment) (raw pass, confidence 0.35)
```
/// ```python
/// foo()  # nоqa  # "о" is Cyrillic (`U+043E`)
/// ```
///
```
info unicode-mixed-script crates/ruff_linter/src/rules/ruff/rules/ambiguous_unicode_character.rs:145:14

identifier `nоqa` mixes scripts: Latin + Cyrillic (in string/comment) (raw pass, confidence 0.40)
```
/// ```python
/// foo()  # nоqa  # "о" is Cyrillic (`U+043E`)
/// ```
///
```
info unicode-homoglyph crates/ruff_linter/src/rules/ruff/rules/ambiguous_unicode_character.rs:145:24

identifier `о` contains homoglyph candidates: о (043E)→o (in string/comment) (raw pass, confidence 0.35)
```
/// ```python
/// foo()  # nоqa  # "о" is Cyrillic (`U+043E`)
/// ```
///
```

info proc-macro-presence crates/ruff_macros/src/lib.rs:23:1

proc-macro attribute `#[proc_macro_derive]` present (ast pass, confidence 0.95)


#[proc_macro_derive(OptionsMetadata, attributes(option, option_group))]
pub fn derive_options_metadata(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

info whitespace-anomaly crates/ruff_python_codegen/src/generator.rs:8:1

file mixes tab and space indentation (1 tab-indented and 2004 space-indented lines) (raw pass, confidence 0.40)

use ruff_python_ast::{
    self as ast, Alias, AnyStringFlags, ArgOrKeyword, BoolOp, BytesLiteralFlags, CmpOp,
    Comprehension, ConversionFlag, DebugText, ExceptHandler, Expr, Identifier, MatchCase, Operator,
    Parameter, Parameters, Pattern, Singleton, Stmt, StringFlags, Suite, TypeParam,

info whitespace-anomaly crates/ruff_python_codegen/src/stylist.rs:13:1

file mixes tab and space indentation (1 tab-indented and 253 space-indented lines) (raw pass, confidence 0.40)
```
pub struct Stylist<'a> {
    indentation: Indentation,
    quote: Quote,
    line_ending: LineEndingDetection<'a>,
```
info ~~warn~~ → info by review whitespace-anomaly crates/ruff_python_codegen/src/stylist.rs:255:1

invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)
```
x = (
⟨U+00A0⟩1,
⟨U+00A0⟩2,
⟨U+00A0⟩3,
```
likely benign LLM, confidence 0.85 Embedded Python sample in a Rust test with non-breaking space indentation.
Reasoning
Raw-pass whitespace flag inside an embedded Python code sample in a Rust test string. Likely a formatting test fixture with nbsp characters; no execution or hiding behavior is evident.
info ~~warn~~ → info by review whitespace-anomaly crates/ruff_python_codegen/src/stylist.rs:256:1

invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)
```
⟨U+00A0⟩1,
⟨U+00A0⟩2,
⟨U+00A0⟩3,
)
```
likely benign LLM, confidence 0.85 Embedded Python tuple sample line with non-breaking space indentation in a Rust test.
Reasoning
Same file and pattern as the adjacent finding; a multi-line Python tuple sample in a test string with nbsp indentation. Benign test data.
info ~~warn~~ → info by review whitespace-anomaly crates/ruff_python_codegen/src/stylist.rs:257:1

invisible whitespace U+00A0 in indentation (raw pass, confidence 0.80)
```
⟨U+00A0⟩2,
⟨U+00A0⟩3,
)
";
```
likely benign LLM, confidence 0.85 Embedded Python tuple sample closing line with non-breaking space indentation in a Rust test.
Reasoning
Same file and pattern; continuation of the embedded Python tuple test sample. No malicious indicators.
info whitespace-anomaly crates/ruff_python_formatter/resources/test/fixtures/black/cases/docstring.py:2:1

file mixes tab and space indentation (12 tab-indented and 95 space-indented lines) (raw pass, confidence 0.40)
```
class MyClass:
  """ Multiline
  class docstring
  """
```
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/black/cases/generics_wrapping.py:1:1

168 of 250 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/black/cases/import_comments.py:1:1

18 of 43 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/black/cases/pep_570.py:1:1

34 of 69 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/black/cases/pep_572_py310.py:1:1

29 of 56 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/black/cases/pep_646.py:1:1

mean non-conventional identifier length 1.88 over 420 names (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/black/cases/percent_precedence.py:1:1

mean non-conventional identifier length 1.15 over 26 names (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/black/cases/power_op_spacing_long.py:1:1

mean non-conventional identifier length 1.00 over 53 names (token pass, confidence 0.50)

info high-complexity crates/ruff_python_formatter/resources/test/fixtures/black/cases/preview_long_strings.py:311:12

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


log.info(f'Skipping: {desc["db_id"]} {foo("bar",x=123)} {"foo" != "bar"} {(x := "abc=")} {pos_share=} {desc["status"]} {desc["exposure_max"]}')

log.info(f'Skipping: {desc["db_id"]} {desc["ms_name"]} {money=} {(x := "abc=")=} {pos_share=} {desc["status"]} {desc["exposure_max"]}')

info ~~critical~~ → info by review dynamic-execution crates/ruff_python_formatter/resources/test/fixtures/black/cases/preview_long_strings__regression.py:20:9

`os.system` called on a non-literal command — runtime-determined shell invocation (ast pass, confidence 0.85)
```
    def foo():
        os.system("This is a regression test. xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxx xxxx.".format("xxxxxxxxxx", "xxxxxx", "xxxxxxxxxx"))
```
likely benign LLM, confidence 0.80 Black formatter test case calling os.system with a formatted string literal.
Reasoning
This is a Black formatter regression fixture. os.system is called with a literal string that has .format applied; the flagged call is inside a test case for long-string formatting. It is not a dropper, though the non-literal flag is technically triggered by the .format call.

info high-complexity crates/ruff_python_formatter/resources/test/fixtures/black/cases/preview_long_strings__regression.py:235:17

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


cmd_fstring = f"sudo -E deluge-console info --detailed --sort-reverse=time_added {'{{}}' if ID is None else ID} | perl -nE 'print if /^{field}:/'"

cmd_fstring = f"sudo -E deluge-console info --detailed --sort-reverse=time_added {{'' if ID is None else ID}} | perl -nE 'print if /^{field}:/'"

info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/black/cases/skip_magic_trailing_comma_generic_wrap.py:1:1

128 of 176 non-conventional identifiers are single-character (73%) (token pass, confidence 0.50)
info whitespace-anomaly crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring.py:2:1

file mixes tab and space indentation (6 tab-indented and 72 space-indented lines) (raw pass, confidence 0.40)
```
def single_line_backslashes1():
  """ content\     """
  return
```
info whitespace-anomaly crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_code_examples.py:12:1

file mixes tab and space indentation (27 tab-indented and 634 space-indented lines) (raw pass, confidence 0.40)
```
def doctest_simple():
    """
    Do cool stuff.
```
info whitespace-anomaly crates/ruff_python_formatter/resources/test/fixtures/ruff/docstring_tab_indentation.py:7:1

file mixes tab and space indentation (28 tab-indented and 8 space-indented lines) (raw pass, confidence 0.40)
```
def tab_argument(arg1: str) -> None:
	"""
	Arguments:
		arg1: super duper arg with 2 tabs in front
```
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/attribute.py:1:1

55 of 126 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)
info whitespace-anomaly crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/lambda.py:27:1

file mixes tab and space indentation (2 tab-indented and 489 space-indented lines) (raw pass, confidence 0.40)
```
lambda x: lambda y: lambda z: (
    x,
    y,
z)  # Trailing
```
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/nested_string_quote_style.py:1:1

mean non-conventional identifier length 1.93 over 41 names (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/tstring.py:1:1

239 of 558 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)

info long-line crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/tuple.py:15:1

line length 569 characters (raw pass, confidence 0.50)

c1 = (("cicero"), ("Qui", "autem,", "si", "maxime", "hoc", "placeat,", "moderatius", "tamen", "id", "uolunt", "fieri,", "difficilem", "quandam", "temperantiam", "postulant", "in", "eo,", "quod", "semel", "admissum", "coerceri", "reprimique", "non", "potest,", "ut", "propemodum", "iustioribus", "utamur", "illis,", "qui"

info whitespace-anomaly crates/ruff_python_formatter/resources/test/fixtures/ruff/expression/unary.py:2:1

file mixes tab and space indentation (2 tab-indented and 129 space-indented lines) (raw pass, confidence 0.40)
```
if not aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb:
    pass

a = True
```
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/ruff/fluent.py:1:1

mean non-conventional identifier length 1.00 over 41 names (token pass, confidence 0.50)
info whitespace-anomaly crates/ruff_python_formatter/resources/test/fixtures/ruff/fmt_on_off/mixed_space_and_tab.py:2:1

file mixes tab and space indentation (1 tab-indented and 9 space-indented lines) (raw pass, confidence 0.40)
```
def test():
 # fmt: off
 	a_very_small_indent
 	(
```
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/ruff/fmt_on_off/off_on_off_on.py:1:1

mean non-conventional identifier length 1.30 over 27 names (token pass, confidence 0.50)
info whitespace-anomaly crates/ruff_python_formatter/resources/test/fixtures/ruff/fmt_skip/compound_one_liners.py:15:1

file mixes tab and space indentation (1 tab-indented and 14 space-indented lines) (raw pass, confidence 0.40)
```
if True:
    for i in range(10): print(i)  # fmt: skip

# Multiple statements in body (should not apply - multiline)
```
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/ruff/parentheses/nested.py:1:1

mean non-conventional identifier length 1.54 over 28 names (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_formatter/resources/test/fixtures/ruff/statement/delete.py:1:1

80 of 98 non-conventional identifiers are single-character (82%) (token pass, confidence 0.50)
info whitespace-anomaly crates/ruff_python_formatter/resources/test/fixtures/ruff/statement/match.py:3:1

file mixes tab and space indentation (22 tab-indented and 474 space-indented lines) (raw pass, confidence 0.40)
```
match foo:  # dangling match comment
    case "bar":
        pass
```
info whitespace-anomaly crates/ruff_python_formatter/resources/test/fixtures/ruff/statement/type_alias.py:42:1

file mixes tab and space indentation (3 tab-indented and 44 space-indented lines) (raw pass, confidence 0.40)
```
type \
	X = int
type X \
	= int
```
info identifier-low-length crates/ruff_python_parser/resources/inline/err/different_match_pattern_bindings.py:1:1

mean non-conventional identifier length 1.98 over 41 names (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_parser/resources/inline/err/duplicate_type_parameter_names.py:1:1

25 of 39 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_parser/resources/inline/err/invalid_annotation_function.py:1:1

32 of 76 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info unicode-mixed-script crates/ruff_python_parser/resources/inline/err/invalid_byte_literal.py:1:6

identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)
```
b'123a𝐁c'
rb"a𝐁c123"
b"""123a𝐁c"""
```
info unicode-mixed-script crates/ruff_python_parser/resources/inline/err/invalid_byte_literal.py:2:4

identifier `a𝐁c123` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)
```
b'123a𝐁c'
rb"a𝐁c123"
b"""123a𝐁c"""
```
info unicode-mixed-script crates/ruff_python_parser/resources/inline/err/invalid_byte_literal.py:3:8

identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)
```
rb"a𝐁c123"
b"""123a𝐁c"""
```
info identifier-low-length crates/ruff_python_parser/resources/inline/ok/ambiguous_lpar_with_items_binary_expr.py:1:1

mean non-conventional identifier length 1.97 over 30 names (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_parser/resources/inline/ok/non_duplicate_type_parameter_names.py:1:1

17 of 30 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_parser/resources/valid/expressions/bool_op.py:1:1

mean non-conventional identifier length 1.73 over 52 names (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_parser/resources/valid/expressions/compare.py:1:1

mean non-conventional identifier length 1.73 over 75 names (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_parser/resources/valid/expressions/lambda.py:1:1

48 of 78 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_parser/resources/valid/expressions/t_string.py:1:1

mean non-conventional identifier length 1.34 over 58 names (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_parser/resources/valid/expressions/tuple.py:1:1

mean non-conventional identifier length 1.33 over 24 names (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_parser/resources/valid/other/decorator.py:1:1

16 of 40 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_parser/resources/valid/statement/delete.py:1:1

mean non-conventional identifier length 1.86 over 21 names (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_parser/resources/valid/statement/function.py:1:1

114 of 262 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)
info identifier-low-length crates/ruff_python_parser/resources/valid/statement/type.py:1:1

100 of 249 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info whitespace-anomaly crates/ruff_python_parser/resources/valid/statement/type.py:27:1

file mixes tab and space indentation (6 tab-indented and 5 space-indented lines) (raw pass, confidence 0.40)
```
type \
	X = int
type X \
	= int
```

info unicode-mixed-script crates/ruff_python_parser/src/lexer.rs:2117:43

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

    fn non_ascii_identifier_flag() {
        let mut lexer = Lexer::new("a€\naβ = β\nascii", Mode::Module, TextSize::default());
        let mut flags = Vec::new();
        loop {

info unicode-mixed-script crates/ruff_python_parser/src/parser/expression.rs:1549:29

identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

                    // test_err invalid_byte_literal
                    // b'123a𝐁c'
                    // rb"a𝐁c123"
                    // b"""123a𝐁c"""

info unicode-mixed-script crates/ruff_python_parser/src/parser/expression.rs:1550:27

identifier `a𝐁c123` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

                    // b'123a𝐁c'
                    // rb"a𝐁c123"
                    // b"""123a𝐁c"""
                    StringType::Bytes(ast::BytesLiteral {

info unicode-mixed-script crates/ruff_python_parser/src/parser/expression.rs:1551:31

identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

                    // rb"a𝐁c123"
                    // b"""123a𝐁c"""
                    StringType::Bytes(ast::BytesLiteral {
                        value: Box::new([]),

info unicode-mixed-script crates/ruff_python_parser/src/string.rs:1149:29

identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)

    fn test_invalid_byte_literal_error() {
        let source = r"b'123a𝐁c'";
        let error = parse_suite(source).unwrap_err();
        insta::assert_debug_snapshot!(error);

info unicode-mixed-script crates/ruff_python_stdlib/src/identifiers.rs:113:32

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

        assert!(is_identifier("кириллица"));
        assert!(is_identifier("πr"));
        assert!(!is_identifier(""));
        assert!(!is_identifier("percentile_co³t"));

info unicode-homoglyph crates/ruff_python_stdlib/src/str.rs:17:27

identifier `αbc` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
/// assert!(is_lowercase("_"));
/// assert!(is_lowercase("αbc"));
/// assert!(!is_lowercase("αBC"));
/// assert!(!is_lowercase("Ωbc"));
```
info unicode-mixed-script crates/ruff_python_stdlib/src/str.rs:17:27

identifier `αbc` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
/// assert!(is_lowercase("_"));
/// assert!(is_lowercase("αbc"));
/// assert!(!is_lowercase("αBC"));
/// assert!(!is_lowercase("Ωbc"));
```
info unicode-homoglyph crates/ruff_python_stdlib/src/str.rs:18:28

identifier `αBC` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
/// assert!(is_lowercase("αbc"));
/// assert!(!is_lowercase("αBC"));
/// assert!(!is_lowercase("Ωbc"));
/// ```
```
info unicode-mixed-script crates/ruff_python_stdlib/src/str.rs:18:28

identifier `αBC` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
/// assert!(is_lowercase("αbc"));
/// assert!(!is_lowercase("αBC"));
/// assert!(!is_lowercase("Ωbc"));
/// ```
```
info unicode-mixed-script crates/ruff_python_stdlib/src/str.rs:19:28

identifier `Ωbc` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
/// assert!(!is_lowercase("αBC"));
/// assert!(!is_lowercase("Ωbc"));
/// ```
pub fn is_lowercase(s: &str) -> bool {
```
info unicode-mixed-script crates/ruff_python_stdlib/src/str.rs:54:27

identifier `ΩBC` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
/// assert!(is_uppercase("_"));
/// assert!(is_uppercase("ΩBC"));
/// assert!(!is_uppercase("Ωbc"));
/// assert!(!is_uppercase("αBC"));
```
info unicode-mixed-script crates/ruff_python_stdlib/src/str.rs:55:28

identifier `Ωbc` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
/// assert!(is_uppercase("ΩBC"));
/// assert!(!is_uppercase("Ωbc"));
/// assert!(!is_uppercase("αBC"));
/// ```
```
info unicode-homoglyph crates/ruff_python_stdlib/src/str.rs:56:28

identifier `αBC` contains homoglyph candidates: α (03B1)→a (in string/comment) (raw pass, confidence 0.35)
```
/// assert!(!is_uppercase("Ωbc"));
/// assert!(!is_uppercase("αBC"));
/// ```
pub fn is_uppercase(s: &str) -> bool {
```
info unicode-mixed-script crates/ruff_python_stdlib/src/str.rs:56:28

identifier `αBC` mixes scripts: Greek + Latin (in string/comment) (raw pass, confidence 0.40)
```
/// assert!(!is_uppercase("Ωbc"));
/// assert!(!is_uppercase("αBC"));
/// ```
pub fn is_uppercase(s: &str) -> bool {
```

info unicode-homoglyph crates/ruff_workspace/src/options.rs:706:44

identifier `ρ` contains homoglyph candidates: ρ (03C1)→p (in string/comment) (raw pass, confidence 0.35)

            # which could be confused for "-", "p", and "*", respectively.
            allowed-confusables = ["−", "ρ", "∗"]
        "#
    )]

info unicode-mixed-script crates/ty_ide/src/selection_range.rs:415:6

identifier `a𝐁` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)
```
                r#"
b"123a𝐁<CURSOR>c"
"#,
            )
```
info unicode-mixed-script crates/ty_ide/src/selection_range.rs:425:20

identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)
```
        1 | /
        2 | | b"123a𝐁c"
          | |__________^
```
info unicode-mixed-script crates/ty_ide/src/selection_range.rs:431:18

identifier `a𝐁c` mixes scripts: Latin + Other (in string/comment) (raw pass, confidence 0.40)
```
          |
        2 | b"123a𝐁c"
          | ^^^^^^^^^
        "#);
```
info identifier-low-length crates/ty_python_semantic/resources/corpus/02_expr_binary.py:1:1

mean non-conventional identifier length 1.00 over 26 names (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/corpus/02_expr_rel.py:1:1

mean non-conventional identifier length 1.31 over 26 names (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/corpus/06_funcall_many_args.py:1:1

mean non-conventional identifier length 1.29 over 24 names (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/corpus/06_funcall_varargs_kwargs_mixed.py:1:1

mean non-conventional identifier length 1.67 over 21 names (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/corpus/10_if_false.py:1:1

20 of 34 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)
info ~~critical~~ → info by review builtins-write crates/ty_python_semantic/resources/corpus/98_ann_assign_annotation_future_annotations.py:5:1

`builtins.__import__ = ...` — patches a built-in for every importer of this module (ast pass, confidence 0.95)
```
builtins.__import__: Callable[..., object] = __import__
```
likely benign LLM, confidence 0.90 Type checker corpus test assigning an annotated builtins.__import__.
Reasoning
This is a type checker corpus file testing annotated assignment to builtins.__import__ with future annotations. It is a semantic test of type inference, not a real supply-chain patch.
info identifier-low-length crates/ty_python_semantic/resources/mdtest/annotations/intersection_types.md:195:1

[embedded python] 18 of 34 non-conventional identifiers are single-character (53%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/annotations/invalid.md:415:1

[embedded python] 24 of 60 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/annotations/new_types.md:525:1

[embedded python] 41 of 61 non-conventional identifiers are single-character (67%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/annotations/string.md:254:1

[embedded python] 18 of 37 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/attributes.md:1585:1

[embedded python] 17 of 38 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/attributes.md:3025:1

[embedded python] 23 of 37 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/attributes.md:3339:1

[embedded python] 17 of 40 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/bidirectional.md:2653:1

[embedded python] 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/binary/booleans.md:8:1

[embedded python] 90 of 140 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/binary/classes.md:22:1

[embedded python] 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/binary/custom.md:387:1

[embedded python] 27 of 42 non-conventional identifiers are single-character (64%) (token pass, confidence 0.50)
info ~~critical~~ → info by review dynamic-import crates/ty_python_semantic/resources/mdtest/call/dunder_import.md:33:17

[embedded python] `__import__` called on a non-literal expression (ast pass, confidence 0.70)
```
    reveal_type(name)  # revealed: Literal["sys", "os"]
    reveal_type(__import__(name))  # revealed: ModuleType

    if flag:
```
likely benign LLM, confidence 0.90 Type checker mdtest exercising reveal_type on a dynamic __import__ call.
Reasoning
This is an mdtest markdown file for the type checker, with reveal_type annotations showing expected inferred types. The __import__ call with a variable name tests type inference of dynamic imports, not malicious use.
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/functools_partial.md:385:1

[embedded python] 13 of 31 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/functools_partial.md:1632:1

[embedded python] 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/overloads.md:175:1

[embedded python] 16 of 35 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/overloads.md:234:1

[embedded python] 21 of 43 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/overloads.md:273:1

[embedded python] 19 of 33 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/overloads.md:600:1

[embedded python] 22 of 51 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/overloads.md:647:1

[embedded python] 29 of 67 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/overloads.md:895:1

[embedded python] 17 of 36 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/overloads.md:954:1

[embedded python] 175 of 362 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/overloads.md:1170:1

[embedded python] 36 of 77 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/overloads.md:1283:1

[embedded python] mean non-conventional identifier length 1.55 over 47 names (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/type.md:1341:1

[embedded python] 17 of 37 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/class/super.md:28:1

[embedded python] 46 of 89 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/class/super.md:497:1

[embedded python] 21 of 50 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/class/super.md:530:1

[embedded python] 19 of 39 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/class/super.md:565:1

[embedded python] 17 of 36 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/comparison/enums.md:47:1

[embedded python] 18 of 31 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/comparison/instances/rich_comparison.md:236:1

[embedded python] 17 of 42 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/comparison/instances/rich_comparison.md:500:1

[embedded python] 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:16:1

[embedded python] 26 of 40 non-conventional identifiers are single-character (65%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:37:1

[embedded python] 28 of 40 non-conventional identifiers are single-character (70%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:61:1

[embedded python] 26 of 41 non-conventional identifiers are single-character (63%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:234:1

[embedded python] 39 of 64 non-conventional identifiers are single-character (61%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:274:1

[embedded python] 30 of 42 non-conventional identifiers are single-character (71%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:311:1

[embedded python] 16 of 33 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/comparison/tuples.md:500:1

[embedded python] 19 of 34 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/diagnostics/semantic_syntax_errors.md:565:1

[embedded python] 24 of 49 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/diagnostics/semantic_syntax_errors.md:637:1

[embedded python] 31 of 74 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/diagnostics/unknown_argument.md:23:1

[embedded python] 17 of 31 non-conventional identifiers are single-character (55%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/directives/assert_type.md:161:1

[embedded python] 14 of 31 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/directives/assert_type.md:246:1

[embedded python] 23 of 54 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/exhaustiveness_checking.md:516:1

[embedded python] 72 of 170 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/final.md:8:1

[embedded python] 14 of 31 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/function/parameters.md:56:1

[embedded python] 17 of 42 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/function/return_type.md:312:1

[embedded python] 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/legacy/callables.md:964:1

[embedded python] 22 of 52 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/legacy/functions.md:1468:1

[embedded python] 21 of 44 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/legacy/functions.md:1637:1

[embedded python] 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/legacy/functions.md:1920:1

[embedded python] 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/legacy/variables.md:312:1

[embedded python] 14 of 33 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/legacy/variables.md:1166:1

[embedded python] 17 of 42 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/legacy/variance.md:25:1

[embedded python] 161 of 351 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/legacy/variance.md:107:1

[embedded python] 155 of 337 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/legacy/variance.md:220:1

[embedded python] 156 of 343 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/aliases.md:595:1

[embedded python] 20 of 34 non-conventional identifiers are single-character (59%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/callables.md:1298:1

[embedded python] 22 of 46 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/classes.md:112:1

[embedded python] 16 of 38 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/classes.md:902:1

[embedded python] 17 of 36 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:1356:1

[embedded python] 15 of 30 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:1515:1

[embedded python] 29 of 69 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:1655:1

[embedded python] 22 of 38 non-conventional identifiers are single-character (58%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:1838:1

[embedded python] 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md:2423:1

[embedded python] 57 of 106 non-conventional identifiers are single-character (54%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/paramspec.md:46:1

[embedded python] 12 of 30 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/paramspec.md:524:1

[embedded python] 28 of 63 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/paramspec.md:862:1

[embedded python] 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:232:1

[embedded python] 15 of 32 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:468:1

[embedded python] 28 of 62 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:572:1

[embedded python] 20 of 42 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:587:1

[embedded python] 28 of 69 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:608:1

[embedded python] 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:619:1

[embedded python] 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:1087:1

[embedded python] 71 of 107 non-conventional identifiers are single-character (66%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:1186:1

[embedded python] 17 of 36 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variables.md:1276:1

[embedded python] 51 of 101 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:32:1

[embedded python] 158 of 341 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:111:1

[embedded python] 158 of 340 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:219:1

[embedded python] 159 of 352 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:295:1

[embedded python] 163 of 351 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:624:1

[embedded python] 40 of 82 non-conventional identifiers are single-character (49%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:647:1

[embedded python] 14 of 32 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:834:1

[embedded python] 27 of 67 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:865:1

[embedded python] 25 of 60 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:1262:1

[embedded python] 15 of 36 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:1783:1

[embedded python] 36 of 69 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/pep695/variance.md:2322:1

[embedded python] 29 of 63 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/scoping.md:354:1

[embedded python] 14 of 33 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/scoping.md:433:1

[embedded python] mean non-conventional identifier length 1.82 over 22 names (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/generics/scoping.md:532:1

[embedded python] 16 of 32 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/implicit_type_aliases.md:798:1

[embedded python] 13 of 32 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/implicit_type_aliases.md:2554:1

[embedded python] 18 of 43 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info ~~critical~~ → info by review builtins-write crates/ty_python_semantic/resources/mdtest/import/builtins.md:329:1

[embedded python] `builtins.foo = ...` — patches a built-in for every importer of this module (ast pass, confidence 0.95)
```
builtins.foo = 123
builtins.bar = 456  # error: [unresolved-attribute]
builtins.baz = 789  # error: [invalid-assignment]
```
likely benign LLM, confidence 0.90 Type checker mdtest assigning to builtins attributes with expected error annotations.
Reasoning
Markdown mdtest for the type checker with inline error comments such as '# error: [invalid-assignment]'. The builtins assignments are intentional test cases verifying diagnostics, not real patching.
info ~~critical~~ → info by review builtins-write crates/ty_python_semantic/resources/mdtest/import/builtins.md:330:1

[embedded python] `builtins.bar = ...` — patches a built-in for every importer of this module (ast pass, confidence 0.95)
```
builtins.foo = 123
builtins.bar = 456  # error: [unresolved-attribute]
builtins.baz = 789  # error: [invalid-assignment]
builtins.chr = lambda x: str(x)  # error: [invalid-assignment]
```
likely benign LLM, confidence 0.90 Type checker mdtest builtins attribute assignment with expected error annotation.
Reasoning
Same mdtest file; the assignment is annotated with an expected diagnostic and exists to test the type checker.
info ~~critical~~ → info by review builtins-write crates/ty_python_semantic/resources/mdtest/import/builtins.md:331:1

[embedded python] `builtins.baz = ...` — patches a built-in for every importer of this module (ast pass, confidence 0.95)
```
builtins.bar = 456  # error: [unresolved-attribute]
builtins.baz = 789  # error: [invalid-assignment]
builtins.chr = lambda x: str(x)  # error: [invalid-assignment]
builtins.chr = 10
```
likely benign LLM, confidence 0.90 Type checker mdtest builtins attribute assignment with expected error annotation.
Reasoning
Same mdtest file; intentional invalid-assignment test case for the type checker.
info ~~critical~~ → info by review builtins-write crates/ty_python_semantic/resources/mdtest/import/builtins.md:332:1

[embedded python] `builtins.chr = ...` — patches a built-in for every importer of this module (ast pass, confidence 0.95)
```
builtins.baz = 789  # error: [invalid-assignment]
builtins.chr = lambda x: str(x)  # error: [invalid-assignment]
builtins.chr = 10
```
likely benign LLM, confidence 0.90 Type checker mdtest reassigning builtins.chr with expected diagnostics.
Reasoning
Same mdtest file; the builtins.chr reassignment is a deliberate test case with expected diagnostics.
info ~~critical~~ → info by review builtins-write crates/ty_python_semantic/resources/mdtest/import/builtins.md:333:1

[embedded python] `builtins.chr = ...` — patches a built-in for every importer of this module (ast pass, confidence 0.95)
```
builtins.chr = lambda x: str(x)  # error: [invalid-assignment]
builtins.chr = 10
```
likely benign LLM, confidence 0.93 Mdtest case that intentionally assigns to a builtin to check that the type checker reports an invalid assignment.
Reasoning
This is a markdown test fixture for a type checker. The `# error: [invalid-assignment]` comment shows the assignment to `builtins.chr` is deliberately invalid and expected to produce a diagnostic. It is a test case, not a runtime patch.
info identifier-low-length crates/ty_python_semantic/resources/mdtest/import/star.md:227:1

[embedded python] 23 of 30 non-conventional identifiers are single-character (77%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/import/star.md:436:1

[embedded python] mean non-conventional identifier length 1.93 over 27 names (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/intersection_types.md:136:1

[embedded python] 40 of 90 non-conventional identifiers are single-character (44%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/intersection_types.md:185:1

[embedded python] 34 of 65 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/mro.md:96:1

[embedded python] 19 of 34 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/mro.md:119:1

[embedded python] 19 of 34 non-conventional identifiers are single-character (56%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/mro.md:142:1

[embedded python] 21 of 49 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/mro.md:168:1

[embedded python] 17 of 37 non-conventional identifiers are single-character (46%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/named_tuple.md:195:1

[embedded python] 20 of 43 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/narrow/aliased_conditions.md:168:1

[embedded python] 19 of 46 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/narrow/assignment.md:8:1

[embedded python] 58 of 139 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/narrow/assignment.md:105:1

[embedded python] 68 of 109 non-conventional identifiers are single-character (62%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/narrow/assignment.md:281:1

[embedded python] 44 of 84 non-conventional identifiers are single-character (52%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/narrow/complex_target.md:131:1

[embedded python] 32 of 67 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)

info unicode-zero-width crates/ty_python_semantic/resources/mdtest/narrow/complex_target.md:146:32

[embedded python] U+200B ZERO WIDTH SPACE in source (in string/comment) (raw pass, confidence 0.45)

        # In this case, it may seem like we can narrow it down to `int`,
        # but different values ⟨U+200B⟩⟨U+200B⟩may be reassigned to `x` and `y` in another place.
        reveal_type(c.y)  # revealed: int | None

info unicode-zero-width crates/ty_python_semantic/resources/mdtest/narrow/complex_target.md:146:35

[embedded python] U+200B ZERO WIDTH SPACE in source (in string/comment) (raw pass, confidence 0.45)

        # In this case, it may seem like we can narrow it down to `int`,
        # but different values ⟨U+200B⟩⟨U+200B⟩may be reassigned to `x` and `y` in another place.
        reveal_type(c.y)  # revealed: int | None

info identifier-low-length crates/ty_python_semantic/resources/mdtest/narrow/conditionals/eq.md:586:1

[embedded python] 36 of 71 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/narrow/conditionals/nested.md:77:1

[embedded python] 25 of 62 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/narrow/conditionals/nested.md:122:1

[embedded python] 51 of 89 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/narrow/conditionals/nested.md:310:1

[embedded python] 31 of 77 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/narrow/type_guards.md:491:1

[embedded python] 14 of 30 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info ~~critical~~ → info by review dynamic-execution crates/ty_python_semantic/resources/mdtest/pep613_type_aliases.md:818:28

[embedded python] `eval` at module scope (runs on import) on a non-literal expression (ast pass, confidence 0.80)
```
# typing conformance cases:
BadTypeAlias1: TypeAlias = eval("".join(map(chr, [105, 110, 116])))  # error: [invalid-type-form]
BadTypeAlias2: TypeAlias = [int, str]  # error: [invalid-type-form]
BadTypeAlias3: TypeAlias = ((int, str),)  # error: [invalid-type-form]
```
likely benign LLM, confidence 0.92 Conformance test case using eval to produce an invalid type alias expression, with an expected error annotation.
Reasoning
This is a typing-conformance mdtest case. The `eval` builds the string 'int' from character codes and is expected to yield an invalid-type-form error. It is a fixture exercising invalid type alias forms, not a runtime dropper, and the code is never run on import in a shipped package.
info identifier-low-length crates/ty_python_semantic/resources/mdtest/pep695_type_aliases.md:390:1

[embedded python] 18 of 36 non-conventional identifiers are single-character (50%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/subscript/tuple.md:595:1

[embedded python] 13 of 30 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/type_properties/constraints.md:1090:1

[embedded python] 14 of 34 non-conventional identifiers are single-character (41%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/type_qualifiers/classvar.md:12:1

[embedded python] 33 of 58 non-conventional identifiers are single-character (57%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/type_qualifiers/classvar.md:145:1

[embedded python] 18 of 42 non-conventional identifiers are single-character (43%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/type_qualifiers/classvar.md:289:1

[embedded python] 33 of 65 non-conventional identifiers are single-character (51%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/typed_dict.md:2087:1

[embedded python] 17 of 42 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/typed_dict.md:4821:1

[embedded python] 19 of 42 non-conventional identifiers are single-character (45%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/unary/not.md:59:1

[embedded python] 15 of 31 non-conventional identifiers are single-character (48%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/unpacking.md:816:1

[embedded python] 72 of 152 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/unreachable.md:541:1

[embedded python] 14 of 33 non-conventional identifiers are single-character (42%) (token pass, confidence 0.50)

info unicode-zero-width crates/ty_python_semantic/src/types/class.rs:1917:73

U+00AD SOFT HYPHEN in source (in string/comment) (raw pass, confidence 0.45)

    /// You must provide the `inherited_generic_context` that we should use for the `__new__` or
    /// `__init__` member. This is inherited from the containing class -⟨U+00AD⟩but importantly, from the
    /// class that the lookup is being performed on, and not the class containing the (possibly
    /// inherited) member.

info unicode-homoglyph crates/ty_python_semantic/src/types/constraints/sequents.rs:630:31