How to Silence Astral ty False Positives in Python with ty: ignore, rule IDs, and file-level ignores

Learn how to suppress Astral ty static type checker warnings in Python using ty: ignore, type: ignore, and rule IDs. Stay productive and avoid false positives.

Pre-release tools are great to experiment with, but they occasionally shout about things you already know are fine. Astral’s static type checker ty is no exception: while it matures, you can hit false-positives or constructs that aren’t handled yet (for example, enums). In such cases it’s useful to silence specific diagnostics without dropping type checking entirely.

Minimal example of the problem

The following code returns an int where a str is annotated, which a type checker will flag. Sometimes, during incremental adoption, you may prefer to proceed and explicitly acknowledge the mismatch.

def to_text(n: int) -> str:
    return n

Why this triggers

The annotation promises a string, but the implementation returns an integer. A type checker like ty is designed to catch exactly this kind of inconsistency. When you’re dealing with temporary gaps in checker support or known false-positives, declaring an intentional suppression is the cleanest way to keep moving while retaining signal from the rest of the file.

Suppression in a single line

If you want to silence all type issues for a specific expression or return, append a suppression directive at the end of the line. The variant specific to ty is ideal for false-positives in this checker.

def labelize(value: int) -> str:
    return value  # ty: ignore

You can also use the cross-tool form that other type checkers (such as mypy) understand.

def labelize(value: int) -> str:
    return value  # type: ignore

Suppress only specific rule(s)

When the diagnostic is legitimate but you want to document that a known rule doesn’t apply here, target it precisely. This keeps everything else in the line type-checked and avoids hiding unrelated issues.

mixed = 42 + "chunk"  # ty: ignore[unsupported-operator]

Multiple rule names can be combined to capture all known, intentional exceptions in one spot.

sum_three("one", 5)  # ty: ignore[missing-argument, invalid-argument-type]

For a concrete single-rule case, this form also works:

quot = 1 / 0  # ty: ignore[division-by-zero]

Silence an entire file

In rare situations—such as a transitional phase—you might choose to mute a whole module. Putting the directive at the top disables type errors in the file.

# type: ignore
def alpha(a: int) -> str:
    return a
def beta(b: str) -> int:
    return b

Why this matters

Granular suppression lets you adopt ty without friction. You keep the benefits of static analysis where it’s accurate, isolate known false-positives, and avoid drowning in noise while the tool evolves. This is especially relevant when certain language features aren’t supported yet and you still want to run type checks elsewhere.

Takeaways

Prefer the narrowest suppression that communicates intent. For a one-off false-positive, use a line-level # ty: ignore. When the rule is known, specify it with # ty: ignore[rule-name] so future changes don’t hide new problems. Reach for # type: ignore at file scope only when you’re explicitly opting out of checks for that module. These patterns make it straightforward to balance strictness with pragmatism while using ty.