You can use the typing module for Callable annotations.

The Callable annotation is supplied a list of argument types and a return type:

from typing import Callable

def func_b(func: Callable[[int], int]) -> int:
    return func(3)

Function annotations are what you make of them.

They can be used for documentation:

def kinetic_energy(mass: 'in kilograms', velocity: 'in meters per second'):
     ...

They can be used for pre-condition checking:

def validate(func, locals):
    for var, test in func.__annotations__.items():
        value = locals[var]
        msg = 'Var: {0}\tValue: {1}\tTest: {2.__name__}'.format(var, value, test)
        assert test(value), msg


def is_int(x):
    return isinstance(x, int)

def between(lo, hi):
    def _between(x):
            return lo <= x <= hi
    return _between

def f(x: between(3, 10), y: is_int):
    validate(f, locals())
    print(x, y)


>>> f(0, 31.1)
Traceback (most recent call last):
   ... 
AssertionError: Var: y  Value: 31.1 Test: is_int

Also see http://www.python.org/dev/peps/pep-0362/ for a way to implement type checking.

There’s two ways you can annotate this. First you could just duplicate the function definition under the second name. Secondly, if you do want to specify it as more of a global variable that may be changed, you can use a Protocol containing only a __call__ method as effectively an advanced Callable type.

Try to use get_type_hints from typing:

from typing import get_type_hints


class Child(Parent):
    a: int
    b: int
    c: float


get_type_hints(Parent)
# {'a': <class 'int'>, 'b': <class 'int'>, 'c': <class 'float'>}

getmro() from introspection may be useful in case of inheritance.