ruff 0.17.1

Source: https://github.com/astral-sh/ruff
Tag scanned: 0.17.1
Compared with: 0.17.0 (1 signals introduced since)
Files: 6735 scanned, 4451 skipped (binary, oversized, or unrecognised)
Signals: 8 critical · 11 warn · 591 info
Scan time: 104.2 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): the 126 most severe of 132 warn and critical signals (113 with a verdict); 113 demoted to info. The rest are unreviewed.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-15 19:42

Signals

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

critical 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__
```
critical 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:
```
critical 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]
```
critical 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]
```
critical 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
```
critical 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
```
critical 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
```

critical 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]

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/import/star.md:1023:1

[embedded python] identifier `__aℓℓ__` mixes scripts: Latin + Other (raw pass, confidence 0.80)
```
__all__ = ["first"]
__aℓℓ__.append("second")
```
```

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 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 ~~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.1/install.sh | sh
powershell -c "irm https://astral.sh/ruff/0.17.1/install.ps1 | iex"
```
likely benign LLM, confidence 0.85 README instruction for pinned-version ruff installation via curl | sh and PowerShell.
Reasoning
This pins a specific ruff version in the official install script URL, with the matching PowerShell irm | iex alternative for Windows. This is normal vendor install documentation.
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.85 CI smoke test runs the installed package's module with --help using an env-provided name.
Reasoning
MODULE_NAME is a workflow-level variable set by the CI matrix/env, used to smoke-test the installed package with --help. Standard release-smoke-test pattern in a trusted repository workflow; the flag is about variable command names, which is a known weak signal here.
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.80 Windows build step uses llvm-readobj to list DLL imports of the compiled binary.
Reasoning
LLVM_READOBJ is set to llvm-readobj (a build tool) and used to inspect COFF imports of the built ruff.exe to check for vcruntime dependencies. Output is written to a file and grepped. Legitimate build verification; the critical severity reflects the runtime-determined command, not evidence of malice.
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.85 CI step installs built wheel and runs a --help smoke test.
Reasoning
Same smoke-test pattern as other instances: installs the built wheel and runs the module with --help. Benign CI 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.85 CI smoke test of installed package via --help.
Reasoning
Repeated smoke-test pattern installing the built package and invoking --help via a CI-set module name. Benign.
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.85 CI smoke test of installed package via --help.
Reasoning
Repeated smoke-test pattern installing the built package and invoking --help. Benign.
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.85 CI smoke test of venv entry point via --help.
Reasoning
Smoke test running the installed venv entry point with --help. Benign.
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.85 CI smoke test of venv entry point via --help.
Reasoning
Smoke test running the installed venv entry point with --help. Benign.
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.70 CI step downloads the hawk installer script from GitHub releases and pipes it to sh.
Reasoning
Piping a curl download from the official astral-sh GitHub releases URL into sh is the standard installer pattern for the tool. It is a supply-chain risk in general, but the source is the project's own release domain with TLS enforced, so it reads as a legitimate install step rather than an obfuscated dropper.
info identifier-low-length .github/workflows/ci.yaml:478:14

[embedded bash] 14 of 35 non-conventional identifiers are single-character (40%) (token pass, confidence 0.50)

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

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

[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.80 Signing workflow installs the signed wheel and runs ruff --help via a python array.
Reasoning
The python array is a shell array holding an interpreter invocation, used to pip install the signed wheel and run ruff --help. Standard release verification; the warning comes from the array-expansion form.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:361:11

[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.80 Signing workflow smoke-tests ruff via python -m ruff --help.
Reasoning
Runs the installed ruff module with --help via the python array. Benign verification step.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:418:11

[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' }
```
dismissed LLM, confidence 0.80 PowerShell step sets ErrorActionPreference and validates the signed wheel count.
Reasoning
The flagged name is a PowerShell automatic preference variable, not a command. The pattern matched a non-command, so this is a false positive in a PowerShell block that sets Stop and validates a single signed wheel.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:419:11

[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.80 PowerShell step locates the single signed wheel and pip installs it.
Reasoning
$wheel is a Get-ChildItem result object, and the step installs its FullName with pip. Local variable use in a trusted signing workflow; the flag is a parser artifact of PowerShell.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:420:17

[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
```
dismissed LLM, confidence 0.90 Release workflow step that locates a signed wheel and installs it with pip.
Reasoning
The flagged token $wheel is an argument to python -m pip install ($wheel.FullName), not a command name. The line is a PowerShell-style wheel install guarded by a count check, so the parser has misread the embedded script. No sign of malicious intent.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:422:15

[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' }
```
dismissed LLM, confidence 0.90 Post-install exit-code check in the release signing workflow.
Reasoning
$LASTEXITCODE is the PowerShell exit-code variable, read in a conditional to throw on failure. It is not executed as a command, so the dynamic-execution signal is a parser artifact.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:424:15

[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' }
```
dismissed LLM, confidence 0.90 Exit-code check after verifying the signed ruff executable runs.
Reasoning
Same pattern as the neighbouring findings: $LASTEXITCODE is checked after running the signed ruff binary to verify it works. No dynamic execution is introduced.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:426:15

[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' }
```
dismissed LLM, confidence 0.90 Exit-code check after the ruff --help smoke test.
Reasoning
$LASTEXITCODE is checked after the ruff help invocation, consistent with a sanity-test step in a release pipeline. The flag comes from a misparse of the PowerShell variable.
info ~~warn~~ → info by review dynamic-execution .github/workflows/sign-release-binaries.yml:428:15

[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' }
```
dismissed LLM, confidence 0.90 Exit-code check after the python -m ruff smoke test.
Reasoning
$LASTEXITCODE is checked after the python -m ruff invocation as a smoke test. This is ordinary CI verification with no obfuscation or malicious payload.
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.85 Documentation step telling contributors to install uv with the official curl | sh script.
Reasoning
The curl-to-sh pattern is the official uv installation instruction from Astral, shown as contributor documentation. It is a widely used but risky install method, not hidden or obfuscated code.
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.85 README instruction installing ruff via the official curl | sh installer on macOS and Linux.
Reasoning
This is the official ruff installation command from the project's README, pointing at the vendor's own domain. It is standard install documentation rather than a supply-chain attack.

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
```
dismissed LLM, confidence 0.90 Test string containing a deliberate U+00A0 to check whitespace handling in the snippet renderer.
Reasoning
The non-breaking space is deliberate test input. The adjacent comment states the expected warning for an unskipped '\u{a0}' symbol, so this is a rustc-compatibility test fixture, not hidden 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
```
dismissed LLM, confidence 0.90 Test-fixture call to os.spawnl with a mode constant, used to exercise the flake8-async lint rule.
Reasoning
This is a linter test fixture. The os.spawnl calls are never executed and exist to trigger ASYNC220 diagnostics, as the trailing comments show. Severity is inflated for a test file.
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
```
dismissed LLM, confidence 0.90 Lint-fixture os.spawnl call annotated with its expected ASYNC220 diagnostic.
Reasoning
The file is a lint fixture where each os.spawnl line is annotated with the rule it should trigger. The calls are inert test cases, not runtime process spawns.
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
```
dismissed LLM, confidence 0.90 Lint-fixture os.spawnl call annotated with its expected ASYNC221 diagnostic.
Reasoning
The annotated ASYNC221 cases in a linter fixture show this is intentional rule-coverage code. Nothing here is executed against a real binary.
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
```
dismissed LLM, confidence 0.90 Lint-fixture edge-case os.spawnl calls with non-path arguments for rule testing.
Reasoning
This is a test fixture covering edge cases for the ASYNC220 rule, with literal and call arguments annotated in comments. It is not a malicious spawn, and the literal-path signal is a weak indicator here.
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.93 Test fixture calling os.spawnl with placeholder arguments to exercise a ruff lint rule.
Reasoning
This is a linter test fixture for ruff's flake8-async rules (ASYNC220), with inline comments naming the expected rule. The os.spawnl calls are intentional test inputs, not malicious code.
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.92 Linter fixture containing os.spawnl(foo()) to test ASYNC220 detection.
Reasoning
The file is a ruff linter test fixture; the non-literal spawnl call foo() is a lint test input with an ASYNC220 comment. The critical severity reflects the scanner's pattern match, not real attack behavior.
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.93 Test fixture calling os.system with a literal 'true' command to exercise rule S605.
Reasoning
This is a ruff flake8-bandit S605 test fixture enumerating shell-invoking functions with literal 'true' commands. It is benign test data.
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.93 Test fixture calling os.popen with a literal 'true' command.
Reasoning
Part of the S605 linter test fixture; os.popen with the literal 'true' command is an intentional test input.
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.93 Test fixture calling subprocess.getoutput with a literal 'true' command.
Reasoning
Linter test fixture for S605 with a harmless literal 'true' command passed to subprocess.getoutput.
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.93 Test fixture calling subprocess.getstatusoutput with a literal 'true' command.
Reasoning
Linter test fixture for S605; the literal 'true' command is harmless and used to test rule 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.90 Test fixture calling os.system with a variable containing 'true'.
Reasoning
Within the S605 test fixture, os.system receives a variable holding the literal 'true'. The critical label is a scanner artifact; this is a rule test input, not a runtime-determined attack.
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.92 Test fixture calling os.system with a list containing a variable.
Reasoning
Same S605 test fixture pattern with a harmless variable command; no malicious intent.
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.92 Test fixture calling os.system with a list argument.
Reasoning
Linter test fixture exercising os.system argument forms; benign.
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.93 Test fixture calling os.spawnl-family functions with 'true'.
Reasoning
S606 linter test fixture calling os process-spawn functions with literal 'true'; benign test data.
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.93 Test fixture calling os.spawnle with 'true'.
Reasoning
Same S606 test fixture pattern with harmless literal arguments.
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.93 Test fixture calling os.spawnlp with 'true'.
Reasoning
Linter test fixture for S606; benign.
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.93 Test fixture calling os.spawnlpe with 'true'.
Reasoning
Linter test fixture for S606; benign.
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.93 Test fixture calling os.spawnv with 'true'.
Reasoning
Linter test fixture for S606; benign.
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.93 Test fixture calling os.spawnve with 'true'.
Reasoning
Linter test fixture for S606; benign.
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.93 Test fixture calling os.spawnvp with 'true'.
Reasoning
Linter test fixture for S606; benign.
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.93 Test fixture calling os.spawnvpe with 'true'.
Reasoning
Linter test fixture for S606; benign.
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")
```
dismissed LLM, confidence 0.95 Test fixture calling os.system and os.popen with literal commands to exercise a linter rule.
Reasoning
This is a test fixture in ruff's linter test suite for the bandit S607 rule. The os.system and os.popen calls use literal harmless commands such as "true", and the file is test input, not shipped code.
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")
```
dismissed LLM, confidence 0.95 Test fixture calling os.popen with a literal harmless command.
Reasoning
Part of the same ruff bandit S607 test fixture. The os.popen call uses the literal harmless command "true", so this is a linter regression case, not a dropper or malicious execution.
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")
```
dismissed LLM, confidence 0.95 Test fixture calling os.spawn* variants with literal placeholder paths.
Reasoning
Ruff bandit S607 test fixture. The os.spawn* calls use literal placeholder paths such as "true" to check that the linter flags literal binary paths. Nothing here is dynamic or malicious.
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")
```
dismissed LLM, confidence 0.95 Test fixture calling os.spawnle with a literal placeholder path.
Reasoning
Same ruff bandit S607 fixture. The os.spawnle call uses the literal placeholder "true" to exercise the rule, which is a legitimate test pattern.
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")
```
dismissed LLM, confidence 0.95 Test fixture calling os.spawnlp with a literal placeholder path.
Reasoning
Ruff bandit S607 test fixture using a literal placeholder path with os.spawnlp. This is linter test input, not an attack.
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")
```
dismissed LLM, confidence 0.95 Test fixture calling os.spawnlpe with a literal placeholder path.
Reasoning
Ruff bandit S607 test fixture. The os.spawnlpe call with the literal "true" is a test case for the rule's detection of literal binary paths.
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")
```
dismissed LLM, confidence 0.95 Test fixture calling os.spawnv with a literal placeholder path.
Reasoning
Ruff bandit S607 test fixture. The os.spawnv call with the literal placeholder "true" exercises the linter rule and is not malicious.
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")
```
dismissed LLM, confidence 0.95 Test fixture calling os.spawnve with a literal placeholder path.
Reasoning
Ruff bandit S607 test fixture. The os.spawnve call uses a literal placeholder and is only linter test input.
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")
```
dismissed LLM, confidence 0.95 Test fixture calling os.spawnvp with a literal placeholder path.
Reasoning
Ruff bandit S607 test fixture. The os.spawnvp call with a literal placeholder path, and the os.startfile reference nearby, are test cases for the rule. There is no dynamic or malicious execution.
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")
```
dismissed LLM, confidence 0.95 Test fixture calling os.spawnvpe with a literal placeholder path.
Reasoning
Ruff bandit S607 test fixture. The os.spawnvpe call with the literal "true" is a linter regression case.
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"])
```
dismissed LLM, confidence 0.95 Test fixture calling os.system with literal full paths to check rule behavior.
Reasoning
Ruff bandit S607 test fixture. The os.system calls use literal paths such as /bin/ls, and the comment states the purpose is to check that full paths do not fail. This is a deliberate linter test case.
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"])
```
dismissed LLM, confidence 0.95 Test fixture calling os.system with literal /bin/ls commands.
Reasoning
Same ruff bandit S607 test fixture with literal /bin/ls calls. These are regression inputs for the linter 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")
```
dismissed LLM, confidence 0.95 Test fixture calling os.system with literal paths, including a Windows-style raw string.
Reasoning
Ruff bandit S607 test fixture with literal os.system commands, including a raw Windows path. This is linter test input.
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")
```
dismissed LLM, confidence 0.95 Test fixture calling os.system with literal list-form arguments.
Reasoning
Ruff bandit S607 test fixture with literal list-form os.system arguments. This is a deliberate test case for the linter.
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
```
dismissed LLM, confidence 0.95 Test fixture calling os.system with a literal list of arguments, referencing a ruff regression issue.
Reasoning
Ruff bandit S607 test fixture with a literal list-form os.system call. It is linter test input, and the trailing comment references a ruff issue, which confirms it is a regression test.
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)
```
dismissed LLM, confidence 0.93 Test fixture calling os.popen and subprocess with literal wildcard commands for the S609 rule.
Reasoning
Ruff bandit S609 wildcard-injection test fixture. The os.popen and subprocess calls use literal wildcard command strings, which are linter test cases for the S609 rule, not an attack.
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.90 Test fixture calling subprocess.Popen with shell=True and a literal command.
Reasoning
This is a test fixture for ruff's S609 rule, which exists to flag shell=True usage. The commands are literal, fixed strings with no attacker-controlled input, so the code demonstrates the pattern rather than performing a real attack.
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 calling subprocess.Popen with shell=True on a literal chown command.
Reasoning
Same S609 test fixture. The shell=True call uses a literal chown command with no dynamic input, which is the intended example for the rule.
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 calling os.system with a literal tar shell command.
Reasoning
Part of the S609 linter test fixture. os.system is called with a fixed tar command and no untrusted input, and the file exists to exercise the rule's detection.
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 Latin and Greek letters in an isort sorting test.
Reasoning
This is an isort test fixture for sorting non-ASCII member names. The mixed Latin and Greek identifier is deliberate test data, not an obfuscation technique.
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 Import of a Greek/Latin mixed-script module name in an isort test.
Reasoning
The file is an isort test for non-ASCII module names. The Greek and Latin identifier mix is intentional fixture data for sort-order behavior.
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.85 Alias using mixed Latin and Greek letterlike characters in a unicode test.
Reasoning
This isort fixture deliberately uses Unicode letterlike symbols and mixed scripts to test handling of non-ASCII names. The code is a test case, not a supply-chain payload.
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 17 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 section.
Reasoning
This is a pydocstyle fixture. A no-break space in docstring indentation is a deliberate formatting edge case the rule tests, and it has no executable effect.
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 within a D208 test.
Reasoning
This is a D208 docstring-indentation test fixture. The no-break space is a deliberate test input and only affects docstring text.
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.
Reasoning
Docstring in a pydocstyle test fixture containing a Chinese sentence with ideographic spaces. The characters are docstring text and the file is a rule test, so this is not malicious.
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 String literal containing a POP DIRECTIONAL FORMATTING character in a bidi test.
Reasoning
This is a pylint E2502 fixture demonstrating bidirectional control characters in a string. The file is a test case for detecting Trojan Source patterns, so the characters are intentional sample data.
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.80 Comparison line with a RIGHT-TO-LEFT OVERRIDE used to demonstrate Trojan Source.
Reasoning
The line reproduces the Trojan Source pattern, with bidi overrides hiding a logic change in a comparison. This is a known-bad sample inside a pylint test fixture for E2502, so it is not a real attack, though the same construction is the real threat.
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.80 LEFT-TO-RIGHT ISOLATE inside a comparison line in a bidi test fixture.
Reasoning
Same E2502 test line as the other bidi findings. The isolate character is part of the intentional sample that the rule is meant to flag.
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.80 POP DIRECTIONAL ISOLATE within a comment in a bidi test line.
Reasoning
Part of the intentional Trojan Source sample in the E2502 fixture. The isolate pops within a comment, which is the pattern under test rather than a real payload.
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.80 Second LEFT-TO-RIGHT ISOLATE in the bidi test comment.
Reasoning
Repeated bidi isolate in the same deliberate E2502 test line. The fixture exists to exercise detection of these characters.
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.85 RIGHT-TO-LEFT ISOLATE inside a docstring in a bidi test.
Reasoning
A RIGHT-TO-LEFT ISOLATE inside a docstring in a pylint bidi test fixture. It is sample data for the rule and does not change executable logic in a real project.
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.90 Test fixture using a Greek alpha identifier to exercise linter behavior.
Reasoning
Greek alpha in a Python test fixture for empty comment handling; a deliberate test case, not a supply-chain homoglyph attack. Raw pass has high false-positive rate.
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.90 Linter test fixture reusing a Greek alpha identifier.
Reasoning
Same Greek alpha identifier in a linter test fixture file; benign test content.
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.93 Test fixture showing subprocess.run calls with shell=True on literal commands.
Reasoning
This is a ruff linter test fixture exercising subprocess.run with shell=True on a literal command; the literal 'ls' is not attacker-controlled and the file is a lint test case.
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.93 Test fixture with subprocess.run calls on literal commands in various check/shell configurations.
Reasoning
Lint test fixture with literal 'ls' commands; no untrusted input and no malicious intent.
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.93 Test fixture with subprocess.run shell=True calls on literal 'ls'.
Reasoning
Same benign linter test fixture using literal shell commands.
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.90 Test fixture that opens its own file to check for a string in a loop.
Reasoning
Reading the file's own source to search for a string is a benign self-inspection pattern in a test fixture; no execution of extracted payload is shown.
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.93 Test helper calling eval on test input for assertion checking.
Reasoning
eval on a function parameter inside a test helper in a linter fixture; expected for testing the rule, not malicious.
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.92 Lint fixture calling eval with a noqa directive to test redirect reporting.
Reasoning
eval(command) appears in a noqa-directive test fixture; it exists to exercise lint rule suppression handling, not as a real attack.
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 Linter fixture with repeated module-level eval lines testing noqa handling.
Reasoning
Repeated module-level eval calls are deliberate test cases for noqa comment normalization in a linter fixture; they do not indicate a real dropper.
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 Linter fixture with module-level eval calls for noqa testing.
Reasoning
Same deliberate noqa test pattern in a linter fixture file.
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 Linter fixture with module-level eval calls for noqa testing.
Reasoning
Same deliberate noqa test pattern in a linter fixture file.
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 Linter fixture with module-level eval calls for noqa testing.
Reasoning
Same deliberate noqa test pattern in a linter fixture file.
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.88 Non-breaking space inside a Rust raw string docstring snippet.
Reasoning
Raw pass flags a non-breaking space in a docstring within a Rust raw string literal, likely inside a test or doc example. Low-risk formatting artifact from the raw pass.

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.88 Non-breaking space in an embedded Python test snippet in Rust source.
Reasoning
Non-breaking space in indentation of a Python snippet embedded in a Rust test string; typical of test fixture formatting and not a real obfuscation vector.
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.88 Non-breaking space in an embedded Python test snippet in Rust source.
Reasoning
Same non-breaking space pattern in an embedded test string for the stylist.
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.88 Non-breaking space in an embedded Python test snippet in Rust source.
Reasoning
Same non-breaking space pattern in an embedded test string for the stylist.
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 ~~warn~~ → info by review 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
```
dismissed LLM, confidence 0.95 Formatter test fixture containing chained power operators on the digit 1.
Reasoning
This is a formatter test fixture exercising power-operator spacing; the file is a sequence of 1** expressions with a narrow character set purely because the content is numeric, not because it is an encoded payload.

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 ~~warn~~ → info by review 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 = '中文測試：代碼點數量少，但在真正的終端模擬器或編輯器中呈現時太長，因此需要換行的字符串。'
```
dismissed LLM, confidence 0.97 Plain Hangul and Hanzi string literals used to test line-length handling.
Reasoning
These are ordinary Korean and Chinese string literals in a formatter test about east-asian width line wrapping; compression ratio on natural-language text is meaningless as obfuscation.
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.93 Formatter regression fixture calling os.system on a formatted literal string.
Reasoning
The os.system call is inside a formatter test fixture, with a string built via .format on a literal template; it is a non-executing regression input for the formatter, not a real dropper, though the flagged pattern is a shell 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 ~~warn~~ → info by review 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
```
dismissed LLM, confidence 0.92 Test fixture of unusual Unicode identifiers including a variation selector.
Reasoning
This is a formatter test fixture deliberately exercising unusual Unicode identifiers, including variation selectors in an identifier; the code is a test of parser handling, not an attack payload.
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 ~~warn~~ → info by review 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():
```
likely benign LLM, confidence 0.90 Formatter fixture using subprocess shell=True with an f-string containing lambdas.
Reasoning
This is a formatter fixture showing lambda formatting inside an f-string passed to subprocess with shell=True; the rm -rf command is a formatting example, not executed code, though the pattern would be risky in real code.
info ~~warn~~ → info by review 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
```
likely benign LLM, confidence 0.90 Formatter fixture with subprocess shell=True and nested lambdas in an f-string.
Reasoning
Same formatter lambda fixture as the sibling finding; the shell call exists only to test expression formatting and is not part of a working malicious payload.
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 ~~warn~~ → info by review 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\
```
dismissed LLM, confidence 0.90 Rust parser test enumerating byte values as \x escape sequences.
Reasoning
This is a parser test table of escape sequences in a Rust source file, enumerating all byte values for string escape testing; the hex escapes are the expected content of a conformance test.
info ~~warn~~ → info by review 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
```
dismissed LLM, confidence 0.90 Continuation of a Rust parser test enumerating byte escape sequences.
Reasoning
Continuation of the same parser test table of byte escapes in Rust string-handling tests; there is no executed payload or obfuscation intent.
info ~~warn~~ → info by review 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\
```
dismissed LLM, confidence 0.90 Rust parser test table of hex escape sequences for string lexing.
Reasoning
Near-duplicate of the other parser test table in string.rs, used to verify escape handling; the content is test data for the lexer.
info ~~warn~~ → info by review 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
```
dismissed LLM, confidence 0.90 Continuation of a Rust parser test table of escape sequences.
Reasoning
Continuation of the duplicate parser test escape table; it is expected test input for a Rust compiler front end.

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 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:1583: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:3023: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:3502: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 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:977:1

[embedded python] 16 of 34 non-conventional identifiers are single-character (47%) (token pass, confidence 0.50)
info identifier-low-length crates/ty_python_semantic/resources/mdtest/call/functools_partial.md:1691: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:965: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:1534: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:1703: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:1986: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:1458: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:734: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:1299: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:949: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:1671: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:1830: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:1970: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:2153: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:2738: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:1088: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:1442: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:1532: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 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 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 ~~warn~~ → info by review 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
```
likely benign LLM, confidence 0.90 A stray zero-width space appears in a prose sentence of a markdown test resource.
Reasoning
A zero-width space in a markdown prose sentence inside an mdtest doc is a typo-level artifact with no execution or hiding purpose; the surrounding text is ordinary documentation.
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:841: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