Ignore typing errors in individual blocks

[exhuma]

It is already possible to silence errors using # type: ignore on individual lines, and - since #626) also for a whole file.

Additionally it would be nice to ignore errors on individual blocks. Especially on a class/function level when abstracting away an untyped library. For example:

class MyAbstraction:

    def __init__(self, url: str) -> None:
        self.hostname = url.host  # <-- I want this to be caught by the type-checker

    def some_call(self) -> int:
        # type: ignore
        result = api.untyped_call()
        return result

    def another_large_call(self) -> int:
        # type: ignore
        result_1 = api.untyped_call_1()
        result_2 = api.untyped_call_2()
        result = result_1 + result_2
        return result

When running mypy in "strict" mode the code will be littered with messages like Call to an untyped function ... in a typed context. Currently the only options are:

• Add # type: ignore on each line causing errors by the external library
  • Disadvantage: Cumbersome (many type-comments needed)
  • Advantage: Only the problematic calls are silenced
• Add # type: ignore to the file
  • Disadvantage: Typing errors unrelated to the external library become invisible
  • Advantage: Only one line to add

The second option is best used if a module contains only calls to the external library. For new projects this is doable, but older/larger code-bases often need some refactoring for this. And this can be error-prone and seems risky to do only for type-hinting.

Having the option to disable errors on either a class-level or block-level would add a lot of flexibility.

[brandtbucher]

See #6830 (the PR that closed #626). It’s not currently possible to get the line number of the colon that immediately precedes an indented block from the AST alone... at least not without resorting to error-prone guessing. We can't reliably tell the difference between this:

def f() -> (
    None
):  # type: ignore
    ...

And this:

def f() -> (
    None):
    # type: ignore
    ...

So I think block-scoped ignores using a # type: ignore comment on the first line are not very likely. Perhaps there is another way, like @no_type_check, but with preserved annotations in the function signature.

I wanted this also, but I don't think it's worth changing mypy's source parsing 🙁.

[JelleZijlstra]

You can use the @typing.no_type_check decorator for this.

[rwarren]

@typing.no_type_check works perfectly (thanks @JelleZijlstra).

Why is this issue still open?

[JelleZijlstra]

The original issue asked for something slightly different (block-scoped type-ignore), which is a bit different from @no_type_check, which is always function-scoped.

I'm not sure block-scoped type-ignores are all that necessary, but it's a reasonable request.

[leonardoramirezr]

Try with:

from typing import Any, cast

import api as untype_api # It is import to use a different name to untyped module
api = cast(Any, untype_api)

class MyAbstraction:
     def some_call(self) -> int:
        result = api.untyped_call() # this shouldn't show type warnings.
        return result

[jentyk]

It would be nice if @typing.no_type_check would be also a class decorator

[kamilturek]

It would be nice if @typing.no_type_check would be also a class decorator

@jentyk According to the docs it should work as well as a class decorator, but it isn't apparently true.
https://docs.python.org/3/library/typing.html#typing.no_type_check

Mentioned here #607.

[analog-cbarber]

pylint supports this type of pragma, so it is clearly theoretically possible.

[analog-cbarber]

Also no_type_check only takes a single argument for the decorated object. There is no way to limit the ignore to one particular class of error. For example. there is no way to apply

# type: ignore[misc]

to a function. You have to ignore everything or write a separate comment for each instance. And if you add a new decorator for this purpose, then using it would mean adding a runtime dependency to mypy just for that.

[filips123]

What about introducing two comments to disable and enable specific rule(s) between them? For example:

class MyAbstraction:
    def __init__(self, url: str) -> None:
        self.hostname = url.host

    def large_call(self) -> int:
        # type: off[no-untyped-call]
        result_1 = api.untyped_call_1()
        result_2 = api.untyped_call_2()
        result_3 = api.untyped_call_2()
        result_4 = api.untyped_call_2()
        result = result_1 + result_2 + result_3 + result_4
        return result
        # type: on[no-untyped-call]

This is also similar to formatters such as Black which uses # fmt: off and # fmt: on comments. It's still not disabling specific rule for a whole block with one comment, but two comments (at the start and the end) for a function are still better than having to put a comment on every line with typing error, especially on larger functions.

[etandel]

What about having something like typing.no_type_check() be usable as a context manager?
For instance:

import typing


class MyAbstraction:
    ...

    def another_large_call(self) -> int:
		x : int = f()  # This is checked

        with typing.no_type_check: # no lines inside this context are checked
	        result_1 = api.untyped_call_1()
	        result_2 = api.untyped_call_2()
	        result = result_1 + result_2

		y: str = g() # this is also checked
        return result