Compile Python module to C extension

I found an interesting blog post: You Should Compile Your Python And Here’s Why. In short: if you have a type-annotated Python code (mypy), then with the command mypyc you can compile it to a C extension. Under Linux, the result will be an .so file, which is a binary format.

Here you can find a concrete example: https://github.com/jabbalaci/SpeedTests/tree/master/python3

Steps:

• We need a type-annotated source code (example). It’s enough to add type hints to functions. It’s not necessary to annotate every single variable.
• Compile it (mypyc main.py). The result is an .so file.
• You can import the .so file as if it were a normal Python module.
• If your project consists of just one file (main.py) that you compiled, here is a simple launcher for it:

#!/usr/bin/env bash

python3 -c "import main; main.main()"

If you do a lot of computation in a function, then with this trick you can make it 4-5 times faster.

I don’t think I would use it very often, but it’s good to know that this thing exists. And all you have to do is to add type hints to your code.

Links

• You Should Compile Your Python And Here’s Why
• mypyc documentation

MonkeyType: generate static type annotations automatically

In my previous post I wrote about mypy that can check type annotations.

MonkeyType (from Instagram) is a project that generates static type annotations by collecting runtime types. It can be a great help if you don’t want to do it manually.

I tried it and it works surprisingly well! However, the idea is to generate type annotations with MonkeyType and review the hints. “MonkeyType’s annotations are an informative first draft, to be checked and corrected by a developer.”

Read the README of the project for an example.

mypy — optional static typing

Problem
Python is awesome, it’s my favourite programming language (what a surprise :)). Dynamic typing allows one to code very quickly. However, if you have a large codebase (and I ran into this problem with my latest project JiVE), things start to get complicated. Let’s take an example:

def extract_images(html):
    lst = []
    ...
    return lst

If I look at this code, then what is “html”? Is it raw HTML (string), or is it a BeautifulSoup object? What is the return value? What is in the returned list? Does it return a list of URLs (a list of strings)? Or is it a list of custom objects that wrap the URLs?

If we used a statically-typed language (e.g. Java), these questions wouldn’t even arise since we could see the types of the parameters and the return value.

Solution
I’ve heard about mypy but I never cared to try it. Until now… “Mypy is an experimental optional static type checker for Python that aims to combine the benefits of dynamic (or “duck”) typing and static typing. Mypy combines the expressive power and convenience of Python with a powerful type system and compile-time type checking.” (source)

Thus, the example above could be written like this:

from typing import List
from bs4 import BeautifulSoup
from myimage import Image

def extract_images(html: BeautifulSoup) -> List[Image]:
    lst = []
    ...
    return lst

And now everything is clear and there is no need to carefully analyse the code to figure out what goes in and what comes out.

This new syntax was introduced in Python 3.6. Actually, if you run such an annotated program, the Python interpreter ignores all these hints. So Python won’t become a statically-typed language. If you want to make these hints work, you need to use “mypy”, which is a linter-like static analyzer. Example:

$ pip install mypy    # you can also install it globally with sudo
$ mypy program.py     # verify a file
$ mypy src/           # verify every file in a folder

With mypy you can analyse individual files and you can also analyse every file in a folder.

If you get warnings that mypy doesn’t find certain modules, then run mypy with these options:

$ mypy program.py --ignore-missing-imports --follow-imports=skip

IDE support
I highly recommend using PyCharm for large(r) projects. PyCharm has its own implementation of a static type checker. You can use type hints out of the box and PyCharm will tell you if there’s a problem. It’s a good idea to combine PyCharm with Mypy, i.e. when you edit the code in the IDE, run mypy from time to time in the terminal too.

Getting started
To get started, I suggest watching/reading these resources:

• Static types for Python, PyCon 2017
• Putting Type Hints to Work in PyCharm
• further YouTube videos
• Mypy HQ
• mypy cheat sheet
• Using mypy with an existing codebase
• Static types in Python, oh my(py)! (blog post about the Zulip project’s experiences with adopting mypy)

It’s really easy to get started with mypy. It took me only 2 days to fully annotate my project JiVE. Now the code is much easier to understand IMO.

Tips
If you have a large un-annotated codebase, proceed from bottom up. Start to annotate files that are leaf nodes in the dependency tree/graph. Start with modules that are most used by others (e.g. helper.py, utils.py, common.py). Then proceed upwards until you reach the main file (that I usually call main.py, which is the entry point of the whole project).

You don’t need to annotate everything. Type hints are optional. The more you add, the better, but if there’s a function that you find difficult to annotate, just skip it and come back to it later.

Annotate the function signatures (type of arguments, type of the return value). Inside a function I don’t annotate every variable. If mypy drops a warning and says a variable should be annotated, then I do it.

Sometimes mypy drops an error on a line but you don’t want to annotate it. In this case you can add a special comment to tell mypy to ignore this line:

    ...    # type: ignore

If a function’s signature has no type hints at all, mypy will skip it. If you want mypy to check that function, then add at least one type hint to it. You can add for instance the return type. If the function is a procedure, i.e. it has no return value, then indicate None as the returned type:

def hello() -> None:
    print("hello")

You can add type hints later. That is, you can write your project first, test it, and when it works fine, you can add type hints at the end.

When to use mypy?
For a small script it may not be necessary but it could add a lot to a large(r) project.

Notes
If you read older blog posts, you may find that they mention the package “mypy-lang”. It’s old. Install the package “mypy” and forget “mypy-lang”. More info here.