如何让类的函数调用自动隐式使用await（无需手动编写）

嘿，我完全懂你这种不想手动给所有异步函数调用加await的心情——尤其是已经有一堆现成代码的时候，挨个改确实挺麻烦的。不过得先明确：Python本身没有原生支持隐式await，毕竟它的设计哲学就是「显式优于隐式」，但我们可以用一些高级技巧（比如AST语法树修改）来实现你想要的效果，当然也要提前给你打个招呼：这种黑魔法有一定风险，得谨慎用。

核心思路：通过AST修改自动注入await #

简单来说，我们可以写一个类装饰器，它会遍历类里的所有异步方法，解析方法的抽象语法树（AST），找到所有self.xxx()的调用，如果xxx本身是异步方法，就自动把调用包裹成await self.xxx()，最后重新编译方法替换原来的版本。

下面是一个可直接运行的示例：

import asyncio
import inspect
import ast
import types

def add_implicit_await(node, async_methods):
    """递归遍历AST节点，给符合条件的方法调用自动添加await"""
    if isinstance(node, ast.Call):
        # 检查是否是调用self的方法（比如self.f2()这种形式）
        if (isinstance(node.func, ast.Attribute) 
            and isinstance(node.func.value, ast.Name) 
            and node.func.value.id == 'self'):
            method_name = node.func.attr
            # 如果这个方法是异步的，就把Call节点包装成Await节点
            if method_name in async_methods:
                return ast.Await(value=node)
    # 递归处理所有子节点，确保不会遗漏嵌套调用
    for field, value in ast.iter_fields(node):
        if isinstance(value, list):
            for i, item in enumerate(value):
                value[i] = add_implicit_await(item, async_methods)
        elif isinstance(value, ast.AST):
            setattr(node, field, add_implicit_await(value, async_methods))
    return node

def auto_await(cls):
    """类装饰器：自动给类内的异步方法调用隐式添加await"""
    # 收集类中所有的异步方法
    async_methods = {
        name: method 
        for name, method in cls.__dict__.items() 
        if asyncio.iscoroutinefunction(method)
    }

    for name, method in async_methods.items():
        try:
            # 获取方法的源码（依赖源码文件存在，交互式环境可能失效）
            source = inspect.getsource(method)
            # 解析源码成AST语法树
            tree = ast.parse(source)
            # 修改AST，注入隐式await
            modified_tree = add_implicit_await(tree.body[0], async_methods)
            # 编译修改后的AST
            compiled = compile(modified_tree, filename=inspect.getfile(method), mode='exec')
            # 创建新的函数替换原方法
            new_func = types.FunctionType(compiled.co_consts[0], cls.__dict__, name=name)
            setattr(cls, name, new_func)
        except Exception as e:
            # 如果获取源码失败（比如交互式环境、编译后的pyc文件），跳过该方法
            print(f"无法自动处理方法 {name}: {str(e)}")
    return cls

# 使用示例
@auto_await
class T(object):
    def __init__(self):
        pass

    async def f1(self):
        self.f2()  # 这里会自动被处理成 await self.f2()
        print("f1 执行完成")

    async def f2(self):
        await asyncio.sleep(1)
        print("f2 执行完成")

async def main():
    t = T()
    await t.f1()

asyncio.run(main())

运行这段代码，你会看到f2先执行完成，然后才打印f1 执行完成，说明self.f2()确实被自动加上了await。

必须注意的风险和局限性 #

1. 场景限制：这个实现只处理了self.xxx()的调用场景，如果是调用其他对象的异步方法（比如other_obj.f()），不会自动添加await。
2. 源码依赖：它需要通过inspect.getsource获取方法源码，所以如果你的代码是在交互式环境中运行，或者已经被编译成了pyc文件，这个方法会直接失效。
3. 可读性损耗：隐式await会让代码的异步行为变得不直观，其他开发者阅读代码时可能会困惑——明明没写await，怎么会等待执行？这直接违反了Python的显式原则。
4. 边缘情况：如果方法调用嵌套在复杂表达式里（比如result = self.f2() + 1），这个简单的AST修改逻辑可能会出错，需要更复杂的处理逻辑。

个人更推荐的方案 #

虽然这个方法能解决你的问题，但我还是建议优先手动添加await——毕竟代码的可读性和可维护性远比少写几个字符重要。如果你的代码量很大，可以用IDE的全局替换功能（比如查找self\.(\w+)\(，替换成await self.$1(），这样既高效又不会破坏代码的可读性。

备注：内容来源于stack exchange，提问作者nicolas chevillot