chore(lint): zero stale ruff and LIT headroom and strip inert type: ignore comments

[mateo-berri]

TLDR

Problem this solves:

• Ruff strict and LIT budgets carry 15.8k stale headroom
• RET504 alone allows 522 net-new unnecessary assignments
• 2465 inert type: ignore comments litter the codebase
• Follow-up to chore(lint): zero out basedpyright headroom for purely local rules #35828 and chore(lint): zero out seven more purely local basedpyright rules #35927 covering the other two gates

How it solves it:

• Set 83 ruff strict limits and 7 LIT limits to live counts
• Remove every type: ignore comment and set LIT009 to 0
• Contagious ANN401 keeps its headroom
• Any net-new violation in the tightened rules now reddens the gate

Relevant issues

Linear ticket

Pre-Submission checklist

Please complete all items before asking a LiteLLM maintainer to review your PR

• I have added meaningful tests
• My PR passes all CI/CD checks (e.g., lint, format, unit tests)
• My PR's scope is as isolated as possible; it only solves 1 specific problem
• I have received a Greptile Confidence Score of at least 4/5 before requesting a maintainer review (Greptile reviews automatically once the PR is opened; only comment @greptileai to re-request a review after pushing changes)

Delays in PR merge?

If you're seeing a delay in your PR being merged, ping the LiteLLM Team on Slack (#pr-review).

Screenshots / Proof of Fix

All runs below were captured at 20d297a with latest staging merged in, except the sweep comparison, which is labeled with its own hash. This PR touches only the two budget files and comments that basedpyright never read, so there is no runtime behavior to exercise; the gates themselves are the end-to-end surface

Both gates green with the tightened limits:

$ python scripts/ruff_strict_gate.py --base origin/litellm_internal_staging
OK: every strict rule is within its codebase ceiling (base origin/litellm_internal_staging)

$ python scripts/type_discipline_gate.py --base origin/litellm_internal_staging
OK: every LIT rule is within its codebase ceiling (base origin/litellm_internal_staging)

A one-line unused import reddening the ruff gate (the file was deleted right after):

$ printf 'import os\n' > litellm/_demo_f401.py
$ python scripts/ruff_strict_gate.py --base origin/litellm_internal_staging
FAIL: strict-rule totals exceed their limit (base origin/litellm_internal_staging):
  F401: total 21 over limit 20 (this change added 1)
Reduce the new violations or remove an equal number elsewhere; the ceiling is the limit in ruff-strict-budget.json.

A **kwargs function reddening the LIT gate (also deleted right after):

$ printf 'def _demo(**kwargs: object) -> None:\n    pass\n' > litellm/_demo_kwargs.py
$ python scripts/type_discipline_gate.py --base origin/litellm_internal_staging
FAIL: LIT-rule totals exceed their limit (base origin/litellm_internal_staging):
  LIT008: total 952 over limit 951 (this change added 1)
Remove the new violations, give each a reason (`# noqa: XXX  # <reason>`, `# pyright: ignore[rule]  # <reason>`, `# mutable-ok: <reason>`, `# cast-ok: <reason>`, `# guard-ok: <reason>`, `# kwargs-ok: <reason>`, `# rebind-ok: <reason>`), or remove an equal number elsewhere; the ceiling is the limit in type-discipline-budget.json.

A type: ignore comment reddening the LIT gate through the new LIT009 zero (also deleted right after). This demo runs with --base HEAD because staging still carries the 2465 ignores this PR removes, so against that base the bystander guard covers any total below 2465 until this merges; HEAD as base models the post-merge state every future PR will face:

$ printf 'from typing import Final\n\nx: Final = 1  # type: ignore\n' > litellm/_demo_ignore.py
$ python scripts/type_discipline_gate.py --base HEAD
FAIL: LIT-rule totals exceed their limit (base HEAD):
  LIT009: total 1 over limit 0 (this change added 1)
Remove the new violations, give each a reason (`# noqa: XXX  # <reason>`, `# pyright: ignore[rule]  # <reason>`, `# mutable-ok: <reason>`, `# cast-ok: <reason>`, `# guard-ok: <reason>`, `# kwargs-ok: <reason>`, `# rebind-ok: <reason>`), or remove an equal number elsewhere; the ceiling is the limit in type-discipline-budget.json.

The comment sweep proven inert, captured at 338e411 before the staging merge shifted the tree total: the basedpyright gate reports the identical error total on the tree with all 2465 comments (checked out from cdfefd7) and on the swept tree

$ python scripts/type_check_gate.py --base origin/litellm_internal_staging   # before the sweep
OK: every rule is within its basedpyright limit or no higher than base (149782 errors total)
$ python scripts/type_check_gate.py --base origin/litellm_internal_staging   # after the sweep
OK: every rule is within its basedpyright limit or no higher than base (149782 errors total)

Type

🚄 Infrastructure

Changes

Same rationale as #35828 and #35927, applied to the two non-basedpyright gates: every rule tightened here is purely local, meaning the violation is caused entirely by the lines the change itself writes, never forced by upstream untyped code, so the fix never extends beyond the change and the rare deliberate case takes a suppression with a reason. An unnecessary assignment before return, a leftover noqa, a naive datetime, a bare loop that should be a comprehension, or a swallowed exception is always the new code's own doing

ruff-strict-budget.json drops 83 limits to the live count measured on this branch point, freeing 2020 violations of headroom. The rules that shed ten or more:

Rule	Old	New
RET504	702	180
RUF100	480	100
ANN001	3097	2849
ANN201	2137	1961
PERF401	142	23
ANN202	941	868
ANN003	831	776
ANN204	724	669
PERF403	74	34
TRY002	547	526
TRY300	879	860
S110	236	220
PLW0602	230	215
TRY201	420	407
ANN205	127	115
B006	188	178
SIM102	324	314
SIM103	129	119

The other 65 rules each shed under ten, mostly the uniform pad that left single-digit rules sitting at a limit of 4 or 5 over a live count of 1 or 2; the diff is the full list. The huge RET504, RUF100, and PERF401 drops are real fixes from the Final-annotation sweep in #35807 whose ratchet never captured them, since ruff stops flagging an assignment once it carries an annotation

The ANN annotation rules count as local because they fire on the signature you are writing, not on what you call: an untyped upstream value can force an Any annotation (which is why the contagious ANN401 keeps its 1848 headroom untouched) but never a missing one. Rules currently sitting above their limit and riding the merge-base guard (TID251, UP007, SIM118, C901, and friends) are also untouched, since lowering an already-breached limit changes nothing

type-discipline-budget.json drops all seven LIT rules with stale headroom to their live counts: LIT008 (**kwargs parameters) 1004 to 951, LIT003 (noqa without reason) 292 to 286, LIT004 (pyright-ignore without codes or reason) 44 to 43, LIT001 (mutable collection annotations) 23348 to 23346, LIT010 (unannotated assignments) 25327 to 16828, LIT011 (parameter rebinds) 8406 to 5603, and LIT009 (type: ignore comments) 2460 to 0. LIT010 and LIT011 had kept a deliberate 1.5x grandfather from #35807, but both are as local as the rest and each has a trivial escape: LIT010 wants a : Final annotation (unpacking and walrus targets are exempt) and LIT011 takes # rebind-ok: <reason>, so new code has no claim on shared headroom

The LIT009 zero is earned rather than ratcheted: this PR deletes every # type: ignore comment in litellm/, 2465 of them across 442 files. pyrightconfig.json sets enableTypeIgnoreComments to false, so basedpyright never honored a single one, and no other type checker runs in CI; the identical 149782 error total before and after the sweep (shown above) proves the comments were pure noise. Dropping a trailing comment sometimes lets ruff format rejoin a previously split line, which reformatted 66 of the touched files; the budgets were re-measured on the formatted tree and no count moved

The gates fail a rule only when its count is both over the limit and above the merge-base count, so pre-existing drift keeps merging fine while any net-new violation in these categories now fails pre-commit and CI, as the demos above show

No tests are added because no code changes; the gate logic enforcing these limits is already covered by tests/test_litellm/test_ruff_strict_gate.py and tests/test_litellm/test_type_discipline_gate.py

Final Attestation

• The tests check the right things, including the edge cases, and regressions in the respective real-world customer use-cases are not possible after this PR

---

Note

^{Cursor Bugbot is generating a summary for commit 20d297a. Configure here.}

[codecov]

Codecov Report

❌ Patch coverage is 50.79101% with 591 lines in your changes missing coverage. Please review.

Files with missing lines	Patch %	Lines
litellm/litellm_core_utils/litellm_logging.py	8.77%	104 Missing ⚠️
litellm/evals/main.py	0.00%	41 Missing ⚠️
litellm/llms/openai/openai.py	29.41%	36 Missing ⚠️
litellm/assistants/main.py	67.27%	18 Missing ⚠️
litellm/main.py	58.53%	17 Missing ⚠️
...llm/litellm_core_utils/prompt_templates/factory.py	53.12%	15 Missing ⚠️
litellm/llms/azure/assistants.py	0.00%	13 Missing ⚠️
litellm/llms/vertex_ai/vertex_ai_non_gemini.py	0.00%	13 Missing ⚠️
litellm/caching/redis_cache.py	47.82%	12 Missing ⚠️
...tellm/litellm_core_utils/get_llm_provider_logic.py	45.45%	12 Missing ⚠️
... and 139 more

📢 Thoughts on this report? Let us know!

[greptile-apps]

Greptile Summary

The PR removes inert type: ignore comments throughout the Python package and tightens Ruff and type-discipline budgets to eliminate stale headroom.

• Sets LIT009 to zero after removing the corresponding comments.
• Ratchets Ruff and remaining LIT limits down to the reported live counts.
• Includes formatter-driven line reflow where suppression removal shortened expressions.

Confidence Score: 5/5

The PR appears safe to merge.

No blocking failure remains.

Important Files Changed

Filename	Overview
ruff-strict-budget.json	Ratchets strict Ruff rule ceilings down to the reported current counts.
type-discipline-budget.json	Tightens all seven stale LIT ceilings and sets the type-ignore-comment allowance to zero.
litellm/init.py	Removes type-ignore suppressions from public imports and type-checking declarations without changing executable behavior.
litellm/_redis.py	Removes inert type-ignore comments and applies formatting-only line reflow around existing Redis configuration logic.
litellm/main.py	Removes type-ignore comments and reformats affected expressions without an identified behavioral change.
litellm/proxy/proxy_server.py	Strips inert type suppressions from proxy code with no accepted runtime or security finding.
litellm/router.py	Removes type-ignore comments and reformats existing routing expressions without an identified semantic change.

_{Reviews (2): Last reviewed commit: "Merge remote-tracking branch 'origin/lit..." | Re-trigger Greptile}

[mateo-berri]

@greptileai

[mateo-berri]

bugbot run

[cursor]

✅ Bugbot reviewed your changes and found no new issues!

Comment @cursor review or bugbot run to trigger another review on this PR

^{Reviewed by Cursor Bugbot for commit 20d297a. Configure here.}

[codspeed-hq]

Merging this PR will not alter performance

✅ 31 untouched benchmarks

---

_{Comparing litellm_zero_ruff_lit_headroom (20d297a) with litellm_internal_staging (b735578)}