Python装饰器绑定函数属性的Pyright类型报错解决问询

一、修复Wrapper类无法访问send_command/get_response的问题 #

这类问题通常是因为Wrapper类未持有目标方法的有效引用，可通过两种方式解决：

• 装饰器初始化时传入方法引用：将send_command和get_response作为参数传入装饰器，在Wrapper类内部保存并调用

  def message_decorator(send_cmd, get_resp):
      def decorator(func):
          class Wrapper:
              def __init__(self):
                  self.send_command = send_cmd
                  self.get_response = get_resp
              
              def sendMessageX(self):
                  msg = func()
                  raw_resp = self.send_command(msg)
                  return self.get_response(raw_resp)
          
          wrapper = Wrapper()
          wrapper.split = True
          return wrapper
      return decorator
  

• 闭包捕获父类实例：若目标方法是装饰器所在类的实例方法，直接通过闭包捕获当前类实例

  class ProtocolHandler:
      def send_command(self, msg):
          # 实现逻辑
          pass
      
      def get_response(self, raw_resp):
          # 实现逻辑
          pass
      
      def message_decorator(self, func):
          class Wrapper:
              def sendMessageX(self):
                  msg = func()
                  raw_resp = self.send_command(msg)
                  return self.get_response(raw_resp)
          
          wrapper = Wrapper()
          wrapper.split = True
          return wrapper
  

二、解决Wrapper与协议X的参数集不匹配问题 #

Pyright的参数集报错，本质是Wrapper方法签名与协议定义不一致，需严格对齐：

• 明确声明参数类型：按照协议X的要求，在Wrapper方法中精确定义参数和返回值类型

  # 假设协议X要求：sendMessageX(param1: int, param2: str) -> ResponseToMessageX
  class Wrapper:
      def sendMessageX(self, param1: int, param2: str) -> ResponseToMessageX:
          # 处理逻辑
          pass
  

• 使用参数规范兼容可变参数：通过ParamSpec和TypeVar实现类型安全的可变参数支持

  from typing import ParamSpec, TypeVar
  
  P = ParamSpec('P')
  R = TypeVar('R', bound=ResponseToMessageX)
  
  class Wrapper:
      def sendMessageX(self, *args: P.args, **kwargs: P.kwargs) -> R:
          # 处理逻辑
          pass
  

三、解决Awaitable[C]非C子类型的问题 #

这类报错是因为异步方法的返回类型标注不符合协议要求，需根据协议定义调整：

• 若协议要求返回Future对象：让dispatchMessageX返回Future[ResponseToMessageX]，内部通过事件循环创建任务

  import asyncio
  from typing import Future
  
  class Wrapper:
      def dispatchMessageX(self) -> Future[ResponseToMessageX]:
          return asyncio.get_event_loop().create_task(self._async_process())
      
      async def _async_process(self) -> ResponseToMessageX:
          raw_resp = await self.send_command(...)
          return self.get_response(raw_resp)
  

• 若协议要求异步函数直接返回响应：将dispatchMessageX定义为async def，返回类型标注为ResponseToMessageX（异步函数本身会隐式返回Awaitable）

  class Wrapper:
      async def dispatchMessageX(self) -> ResponseToMessageX:
          raw_resp = await self.send_command(...)
          return self.get_response(raw_resp)
  

四、修复无法调用父对象方法的问题 #

核心是让Wrapper类持有父对象的有效引用：

• 在装饰器中传入父实例：将父对象作为参数传入装饰器，在Wrapper内部保存并调用其方法

  def message_decorator(parent_instance):
      def decorator(func):
          class Wrapper:
              def __init__(self):
                  self.parent = parent_instance
              
              def sendMessageX(self):
                  self.parent.some_parent_method()
                  # 其他逻辑
                  pass
          
          return Wrapper()
      return decorator
  

• 使用Mixin继承父类：让Wrapper继承包含目标方法的父类，直接调用继承的方法

  class BaseProtocol:
      def some_parent_method(self):
          pass
  
  class Wrapper(BaseProtocol):
      def sendMessageX(self):
          self.some_parent_method()
          # 其他逻辑
          pass
  

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