Tools for static type checking in Python

Question

I\'m working with a large existing Python codebase and would like to start adding in type annotations so I can get some level of static checking. I\'m imagining something l

Answer 1

There is the 'gradual' package for Python 3; see PIP or the Bitbucket Repo

Apparently this is an implementation by the group around Jeremy Siek who seems to be quite an authority in the field of gradual typing.

Some annotations are apparently necessary, here is an example:

from gradual import *

@typed
def calculate_total(a:int, b:int) -> int:
    return a + b//100

As far as annotations go, this is not so bad. I have not used the package so I cannot speak to its quality, but the syntax (and the people behind it) certainly make it look promising.

Answer 2

I don't know if this helps but for what it's worth, Jeremy Siek at U of Colorado did some work on gradual typing, and I found this doing a quick search. http://www.wiki.jvmlangsummit.com/pdf/28_Siek_gradual.pdf

My guess (I might be wrong) is there isn't any promising open source tools you can find at the moment since his research looks relatively new.

Your best bet might be to contact the authors and ask if they can release their code to you.

Answer 3

I like prospector, backend of landscape.io. It combines output of existing analyzers, such as pylint, pyflakes, pep8, frosted..., into one report. Neat.

Answer 4

You may find mypy interesting. It has been proposed for inclusion in Python 3.5 by Guido.

Answer 5

Edit 2016-11-11: Just use mypy. Type hints can be added gradually. In Python 3 source code, it verifies standard PEP 484 type hints. Types can still be expressed in Python 2 using special comments. Guido likes it.

This post was originally written a long time ago before mypy was a thing. I've preserved the post's original content below, even though it isn't quite accurate.

---

Original post:

You might want to check out some of the projects mentioned in this related StackOverflow post on static analysis for Python.

In summary:

• pylint
• PyFlakes
• PyChecker

Since Python uses duck typing extensively, things that might be called "type errors" in other languages might end up being "object X doesn't support method Y" in Python.

Edit 2011-05-17:

I agree with delnan that static typing is not possible for Python [apparently wrong]. But since our skepticism doesn't seem to deter you, I can only give you more information on the subject. I present:

• A discussion of type inference for Python. (Other links are from here.)
• Guido van van Rossum's articles on adding optional static typing: part 1 and part 2.
• RPython, a subset of Python that might stand a chance of being statically analyzed enough to do some form of type checking.

Answer 6

I had a similar need some time ago. All the existing solutions that I've found had some problem or does not have a feature that I'd like to have, so I've made my own.

Here's how you use it:

from requiretype import require

@require(name=str, age=(int, float, long))
def greet_person(name, age):
    print "Hello {0} ({1})".format(name, age)

>>> greet_person("John", 42)
Hello John (42)

>>> greet_person("John", "Doe")
# [...traceback...]
TypeError: Doe is not a valid type.
Valid types: <type 'int'>, <type 'float'>, <type 'long'>

>>> greet_person(42, 43)
# [...traceback...]
TypeError: 42 is not a <type 'str'> type

I hope this is useful for you.

For more details look at:

• https://pypi.python.org/pypi/RequireType
• https://github.com/ivanalejandro0/RequireType

P.S.: (quoting myself from github repo)

For most cases I'd recommend using tests instead of type checking since it's more natural to do that in Python. But, there are some cases where you want/need to specify a specific type to use and since python does not have type checks for parameters here's where this is useful.