Checking if something is callable or async callable in Python#

I wanted a mechanism to check if a given Python object was “callable” - could be called like a function - or “async callable” - could be called using await obj().

I ended up writing this helper function to help introspect objects and answer those questions:

1
import asyncio
2
import types
3
from typing import NamedTuple, Any
4

5

6
class CallableStatus(NamedTuple):
7
    is_callable: bool
8
    is_async_callable: bool
9

10

11
def check_callable(obj: Any) -> CallableStatus:
12
    if not callable(obj):
13
        return CallableStatus(False, False)
14

15
    if isinstance(obj, type):
16
        # It's a class
17
        return CallableStatus(True, False)
18

19
    if isinstance(obj, types.FunctionType):
20
        return CallableStatus(True, asyncio.iscoroutinefunction(obj))
21

22
    if hasattr(obj, "__call__"):
23
        return CallableStatus(True, asyncio.iscoroutinefunction(obj.__call__))
24

25
    assert False, "obj {} is somehow callable with no __call__ method".format(repr(obj))

check_callable(obj) returns a CallableStatus named tuple, with an is_callable boolean saying if it can be caled and an is_async_callable boolean specifying if you need to use await with it.

I wrote these pytest tests to exercise the check_callable() function:

1
import pytest
2

3

4
class AsyncClass:
5
    async def __call__(self):
6
        pass
7

8

9
class NotAsyncClass:
10
    def __call__(self):
11
        pass
12

13

14
class ClassNoCall:
15
    pass
16

17

18
async def async_func():
19
    pass
20

21

22
def non_async_func():
23
    pass
24

25

26
@pytest.mark.parametrize(
27
    "obj,expected_is_callable,expected_is_async_callable",
28
    (
29
        (async_func, True, True),
30
        (non_async_func, True, False),
31
        (AsyncClass(), True, True),
32
        (NotAsyncClass(), True, False),
33
        (ClassNoCall(), False, False),
34
        (AsyncClass, True, False),
35
        (NotAsyncClass, True, False),
36
        (ClassNoCall, True, False),
37
        ("", False, False),
38
        (1, False, False),
39
        (str, True, False),
40
    ),
41
)
42
def test_check_callable(obj, expected_is_callable, expected_is_async_callable):
43
    status = check_callable(obj)
44
    assert status.is_callable == expected_is_callable
45
    assert status.is_async_callable == expected_is_async_callable

See this commit for my initial implementation.