Python批量扩展外部类并支持IDE代码补全的实现方案

我有多个来自外部包的类（例如OrigClass1至OrigClass100），想要对它们进行扩展——给每个类添加同一组属性和方法。特别要求：原类和扩展部分的所有属性/方法都能在IDE中被自动补全和识别。

方案1：手动定义子类（可行但繁琐） #

通过创建大量继承原类和扩展类的新类实现：

# 外部包中的代码
class OrigClass1:
    def __init__(self, arg_1_1):
        self.val_1_1 = arg_1_1

# 其他大量类似类...

# 我的扩展类
class Extension:
    def __init__(self, arg_ext):
        self.val_ext = arg_ext

    def do_cool_stuff(self):
        print(self.val_ext)

# 定义扩展后的类
class ExtClass1(OrigClass1, Extension):
    def __init__(self, arg_1_1, arg_ext):
        OrigClass1.__init__(self, arg_1_1)
        Extension.__init__(self, arg_ext)
        
# 还有大量类似的子类定义...

# 所有属性/方法都能自动补全
obj1 = ExtClass1(arg_1_1=1, arg_ext="A")
print(obj1.val_1_1)
print(obj1.val_ext)
obj1.do_cool_stuff()

问题：该方案过于繁琐。虽然可以写代码自动生成这些类定义，但会留下大量无意义代码，不利于可读性和后续维护。理想情况是无需显式定义__init__即可实现继承。

方案2：直接多重继承（不可行） #

# 外部包中的代码
class OrigClass1:
    def __init__(self, arg_1_1):
        self.val_1_1 = arg_1_1

# 我的扩展类
class Extension:
    def __init__(self, arg_ext):
        self.val_ext = arg_ext

    def do_cool_stuff(self):
        print(self.val_ext)

# 定义扩展后的类
class ExtClass1(OrigClass1, Extension):
    pass

# 以下代码无法运行
obj1 = ExtClass1(arg_1_1=1, arg_ext="A")
print(obj1.val_1_1)
print(obj1.val_ext)
obj1.do_cool_stuff()

问题：代码无法运行，因为Extension类从未被初始化，且arg_ext会被传递给原类的构造函数，导致参数不匹配。

方案3：装饰器扩展（部分可行） #

尝试用装饰器解决：

# 外部包中的代码
class OrigClass1:
    def __init__(self, arg_1_1):
        self.val_1_1 = arg_1_1

# 我的扩展类
class Extension:
    def __init__(self, arg_ext):
        self.val_ext = arg_ext

    def do_cool_stuff(self):
        print(self.val_ext)

# 装饰器
def class_extendor(cls):
    init_func = cls.__init__

    def __init__(self, arg_ext, *args, **kwargs):
        init_func(self, *args, **kwargs)
        Extension.__init__(self, arg_ext)

    cls.__init__ = __init__
    return cls

# 定义扩展后的类
@class_extendor
class ExtClass1(OrigClass1):
    pass

# 运行时能访问属性，但IDE无法补全方法
obj1 = ExtClass1(arg_1_1=1, arg_ext="A")
print(obj1.val_1_1)
print(obj1.val_ext)
obj1.do_cool_stuff()  # IDE无法识别该方法

问题：虽然初始化时val_ext会被赋值给对象，但do_cool_stuff方法并未被添加到类中。即使手动逐个添加方法，由于类是运行时动态修改的，PyCharm等IDE无法提供自动补全。

方案4：泛型扩展（不可行但期望可行） #

import typing as t

# 外部包中的代码
class OrigClass1:
    def __init__(self, arg_1_1):
        self.val_1_1 = arg_1_1

ORIG_TYPE = t.TypeVar("ORIG_TYPE")

# 我的扩展类
class Extension(t.Generic[ORIG_TYPE]):
    def __init__(self, arg_ext, *args, **kwargs):
        ORIG_TYPE.__init__(*args, **kwargs)  # 逻辑错误
        self.val_ext = arg_ext

    def do_cool_stuff(obj):
        print(obj.val_ext)

class ExtClass1(Extension[OrigClass1]):
    pass

# 期望的使用方式（实际无法运行）
obj1 = ExtClass1(arg_1_1=1, arg_ext="A")
print(obj1.val_1_1)
print(obj1.val_ext)
obj1.do_cool_stuff(obj1)

问题：代码无法运行，不仅因为ORIG_TYPE.__init__的调用逻辑错误，还因为原类的属性和方法并未被暴露出来。但这种泛型风格看起来有实现的可能。

能否给出简化方案1的建议，或者提供类似方案4的可行方案？对于方案3，有没有办法强制让类型检查器识别添加的属性和方法？

可行解决方案 #

方案A：Mixin类 + 类工厂（简化方案1） #

利用Mixin类和工厂函数自动生成扩展子类，既避免手动编写大量重复代码，又保证IDE能识别所有类型成员。

from typing import Type, TypeVar

# 外部包中的类示例
class OrigClass1:
    def __init__(self, arg_1_1):
        self.val_1_1 = arg_1_1

class OrigClass2:
    def __init__(self, arg_2_1, arg_2_2):
        self.val_2_1 = arg_2_1
        self.val_2_2 = arg_2_2

# 扩展Mixin类：兼容任意原类的初始化逻辑
class ExtensionMixin:
    def __init__(self, *args, arg_ext: str, **kwargs):
        super().__init__(*args, **kwargs)  # 自动调用原类构造函数
        self.val_ext = arg_ext

    def do_cool_stuff(self):
        print(f"Cool stuff with {self.val_ext}")

# 类工厂：一键生成扩展子类
T = TypeVar("T")
def create_extended_class(orig_class: Type[T]) -> Type[T]:
    return type(
        f"Ext{orig_class.__name__}",
        (orig_class, ExtensionMixin),
        {}
    )

# 生成扩展类
ExtClass1 = create_extended_class(OrigClass1)
ExtClass2 = create_extended_class(OrigClass2)

# 使用示例：所有属性/方法均支持IDE自动补全
obj1 = ExtClass1(arg_1_1=1, arg_ext="A")
print(obj1.val_1_1)
print(obj1.val_ext)
obj1.do_cool_stuff()

obj2 = ExtClass2(arg_2_1=2, arg_2_2="B", arg_ext="C")
print(obj2.val_2_1, obj2.val_2_2)
obj2.do_cool_stuff()

优势：

1. 无需手动定义每个子类，一行代码生成一个扩展类
2. IDE能完整识别原类和Mixin的所有属性/方法
3. 初始化逻辑通过super()自动适配原类，避免手动调用多个构造函数

方案B：装饰器 + 类型协议（改进方案3） #

通过添加类型协议让IDE识别扩展成员，同时完善装饰器逻辑自动复制扩展方法，兼顾运行时功能和类型提示。

from typing import Type, TypeVar, Protocol

# 定义扩展协议：告知IDE扩展后的类拥有哪些成员
class ExtendedProtocol(Protocol):
    val_ext: str
    def do_cool_stuff(self) -> None: ...

# 外部包中的类
class OrigClass1:
    def __init__(self, arg_1_1):
        self.val_1_1 = arg_1_1

# 扩展逻辑的载体类
class Extension:
    def __init__(self, arg_ext):
        self.val_ext = arg_ext

    def do_cool_stuff(self):
        print(self.val_ext)

T = TypeVar("T", bound=object)
def class_extendor(cls: Type[T]) -> Type[T & ExtendedProtocol]:
    orig_init = cls.__init__

    # 重写构造函数，同时初始化原类和扩展逻辑
    def new_init(self, *args, arg_ext: str, **kwargs):
        orig_init(self, *args, **kwargs)
        Extension.__init__(self, arg_ext)

    # 复制Extension的所有非特殊方法到目标类
    for name, method in Extension.__dict__.items():
        if not name.startswith("__"):
            setattr(cls, name, method)

    cls.__init__ = new_init
    return cls

# 使用装饰器扩展类
@class_extendor
class ExtClass1(OrigClass1):
    pass

# 使用示例：IDE自动补全所有属性和方法
obj1 = ExtClass1(arg_1_1=1, arg_ext="A")
print(obj1.val_1_1)
print(obj1.val_ext)
obj1.do_cool_stuff()

优势：

1. 保留装饰器的简洁性，无需定义子类
2. 通过Protocol让IDE识别扩展成员，支持自动补全
3. 装饰器自动复制扩展方法，运行时和类型检查均正常工作

方案C：泛型Mixin（方案4的可行版） #

结合泛型和Mixin实现类型安全的扩展，符合方案4的风格，同时保证IDE能识别所有成员。

from typing import TypeVar, Generic

T = TypeVar("T")

# 泛型扩展Mixin
class ExtensionMixin(Generic[T]):
    def __init__(self, *args, arg_ext: str, **kwargs):
        super().__init__(*args, **kwargs)  # 调用原类构造函数
        self.val_ext = arg_ext

    def do_cool_stuff(self):
        print(f"Cool stuff with {self.val_ext}")

# 外部包中的类
class OrigClass1:
    def __init__(self, arg_1_1):
        self.val_1_1 = arg_1_1

# 定义扩展类：继承原类和泛型Mixin
class ExtClass1(OrigClass1, ExtensionMixin[OrigClass1]):
    pass

# 使用示例：所有成员均支持IDE自动补全
obj1 = ExtClass1(arg_1_1=1, arg_ext="A")
print(obj1.val_1_1)
print(obj1.val_ext)
obj1.do_cool_stuff()

优势：

1. 符合泛型风格，类型关系清晰
2. IDE能完整识别原类和Mixin的所有属性/方法
3. 初始化逻辑自动适配原类，无需手动处理构造函数调用

内容的提问来源于stack exchange，提问作者yassem