子类化subprocess.Popen时如何保留类型检查与类型提示

我想要子类化/封装subprocess.Popen，但该类拥有大量参数。目前已知两种常规解决方式：

1. 硬编码所有参数 #

class MyPopen1(subprocess.Popen):
    def __init__(self, myarg1, myarg2, bufsize=-1, executable=None,
                 stdin=None, stdout=None, stderr=None,
                 preexec_fn=None, close_fds=True,
                 shell=False, cwd=None, env=None, universal_newlines=None,
                 startupinfo=None, creationflags=0,
                 restore_signals=True, start_new_session=False,
                 pass_fds=(), *, user=None, group=None, extra_groups=None,
                 encoding=None, errors=None, text=None, umask=-1, pipesize=-1,
                 process_group=None):

        arguments = self.handle_custom_arguments(myarg1, myarg2)
        super().__init__(arguments, bufsize, executable,
                 stdin, stdout, stderr,
                 preexec_fn, close_fds,
                 shell, cwd, env, universal_newlines,
                 startupinfo, creationflags,
                 restore_signals, start_new_session,
                 pass_fds, user=user, group=group, extra_groups=extra_groups,
                 encoding=encoding, errors=errors, text=text, umask=umask, pipesize=pipesize,
                 process_group=process_group)

这种方式能保留完整的类型信息，但缺点是需要维护所有父类参数，Python版本更新导致subprocess.Popen新增参数时，必须手动同步修改。

2. 使用*args与**kwargs #

class MyPopen2(subprocess.Popen):
    def __init__(self, myarg1, myarg2, *args, **kwargs):
        arguments = self.handle_custom_arguments(myarg1, myarg2)
        super().__init__(arguments, *args, **kwargs)

这种写法简洁，无需随父类参数变更而维护，但缺乏类型信息，无法进行静态类型检查，编辑器也无法给出函数签名提示。

尝试用@functools.wraps(subprocess.Popen.__init__)也不是理想方案：它要求子类__init__的签名与父类完全一致，还会覆盖子类的文档字符串等属性，不符合装饰器的设计意图：

# 非理想方案
class MyPopen3(subprocess.Popen):
    @functools.wraps(subprocess.Popen.__init__)
    def __init__(self, myarg1: int, myarg2: str, *args, **kwargs):
        """
        :param myarg1: does foo
        :param myarg2: does bar
        """
        arguments = self.handle_custom_arguments(myarg1, myarg2)
        super().__init__(arguments, *args, **kwargs)

我理想的类型签名如下：

def __init__(self, 
             myarg1: int, myarg2: str, 
             *args: ArgsOf[subprocess.Popen.__init__][1:], 
             **kwargs: KwargsOf[subprocess.Popen.__init__]):

请问是否有方法实现这种效果？如果没有，这类场景下该如何保留类型检查？

方法一：使用typing.Args和typing.Kwargs（Python 3.10+） #

Python 3.10及以上版本的标准库typing模块提供了Args和Kwargs类型，可以直接提取函数的位置参数和关键字参数类型。结合类型定义，可以实现你想要的类型签名：

from typing import Args, Kwargs, Callable
import subprocess

# 定义父类__init__的调用类型
PopenInit = Callable[..., subprocess.Popen]

class MyPopen(subprocess.Popen):
    def __init__(
        self,
        myarg1: int,
        myarg2: str,
        *args: Args[PopenInit][1:],  # 跳过父类__init__的第一个参数self
        **kwargs: Kwargs[PopenInit]
    ):
        arguments = self.handle_custom_arguments(myarg1, myarg2)
        super().__init__(arguments, *args, **kwargs)
    
    def handle_custom_arguments(self, myarg1: int, myarg2: str) -> list[str]:
        # 自定义参数处理逻辑示例
        return ["echo", f"{myarg1}-{myarg2}"]

这里Args[PopenInit][1:]跳过了父类__init__的第一个参数self，因为子类的__init__已经处理了自身的self，剩下的位置参数直接传递给父类。

方法二：兼容旧版本Python（使用typing_extensions） #

如果需要兼容Python 3.9及以下版本，可以安装typing_extensions库，它提供了和标准库一致的Args和Kwargs类型：

pip install typing-extensions

然后修改导入语句：

from typing_extensions import Args, Kwargs

其余代码和方法一完全一致。

方法三：折中方案（无需依赖新类型） #

如果不想使用上述类型工具，可以在子类__init__中给自定义参数添加类型注解，同时在文档字符串中明确说明接受subprocess.Popen的所有参数，配合静态类型检查工具的配置来实现类型检查：

import subprocess

class MyPopen(subprocess.Popen):
    def __init__(self, myarg1: int, myarg2: str, *args, **kwargs):
        """
        自定义Popen子类，接受subprocess.Popen的所有参数，新增以下自定义参数：
        
        :param myarg1: 自定义参数1，用于生成命令参数
        :param myarg2: 自定义参数2，用于生成命令参数
        :param args: subprocess.Popen的位置参数（除第一个命令参数外）
        :param kwargs: subprocess.Popen的关键字参数
        """
        arguments = self.handle_custom_arguments(myarg1, myarg2)
        super().__init__(arguments, *args, **kwargs)
    
    def handle_custom_arguments(self, myarg1: int, myarg2: str) -> list[str]:
        return ["echo", f"{myarg1}-{myarg2}"]

这种方式虽然无法让编辑器自动提示父类参数，但静态检查工具（如mypy、pyright）可以通过分析父类的类型信息，对传递的参数进行类型校验。

验证类型检查 #

使用mypy或pyright检查上述代码时，会自动校验传递给MyPopen的参数是否符合subprocess.Popen的类型要求，同时也会检查自定义参数myarg1和myarg2的类型。

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