Python3.8下ctypes函数类型提示问题排查与优化咨询

要求 #

解决方案必须支持Python 3.8

问题 #

1. 我的代码哪里出现了错误？
2. 是否有更简洁的方式表达需求：get_ctypes_func()返回一个可调用对象，接收arg_types指定类型的参数，返回ret_type类型的值？当前方案是否过度设计？
3. 我想要的功能在Python3.8中是否可行？或是在任意Python版本中可行？

代码实现 #

import ctypes
from collections.abc import Sequence
from typing          import (
  TypeVar, Protocol, Generic, Optional, cast as TYPE_CAST
)

_T = TypeVar('_T', bound=type)
_T = TypeVar('_U', covariant=True, bound=type)

class CTypesCallable(Protocol[_T, _U]):
  # work around a bug in mypy: 
  # error: "CTypesCallable[_T, _U]" has no attribute "__name__"
  __name__: str

  @property
  def argtypes(self) -> Sequence[type[_T]]: ...

  def __call__(self, *args: _T) -> _U: ...

class CTypesFunction(Generic[_T, _U]):
  def __init__(self, function: CTypesCallable[_T, _U]) -> None:
    self.function = function
    return

  def __call__(self, *args: _T) -> _U:
    # do some pre-processing/arg validation
    ret = self.function(*args)
    # do some post-processing and return validation
    return ret

def get_ctypes_func(
  name:      str, 
  arg_types: Sequence[type[_T]], 
  ret_type:  Optional[type[_U]] = None
) -> CTypesFunction[_T, _U]:
  if ret_type is None:
    ret_type = ctypes.c_uint

  func = getattr(some_c_lib, name)
  return CTypesFunction(TYPE_CAST(CTypesCallable[_T, _U], func))

使用示例 #

ret = get_ctypes_func(
  'foo', 
  [SomePythonType, int, float]
)(SomePythonType(), 1, 2.0) # ret is int

错误信息 #

error: Incompatible types in assignment (expression has type
"Type[c_uint]", variable has type "Optional[Type[_U]]")  [assignment]
        ret_type = ctypes.c_uint
                   ^~~~~~~~~~~~~

error: Need type annotation for "ret"  [var-annotated]
        ret = get_ctypes_func('foo', [SomePythonType, int, float])(SomePythonType(), 1, 2.0)
              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

error: Argument 1 to "__call__" of "CTypesFunction" has incompatible
type "SomePythonType"; expected <nothing>  [arg-type]
        foo = get_ctypes_func('foo', [SomePythonType, int, float])(SomePythonType(), 1, 2.0)
                                                                   ^~~~~~~~~~~~~~~~

error: Argument 2 to "__call__" of "CTypesFunction" has incompatible
type "int"; expected <nothing>  [arg-type]
        foo = get_ctypes_func('foo', [SomePythonType, int, float])(SomePythonType(), 1, 2.0)
                                                                                     ^

error: Argument 3 to "__call__" of "CTypesFunction" has incompatible
type "float"; expected <nothing>  [arg-type]
        foo = get_ctypes_func('foo', [SomePythonType, int, float])(SomePythonType(), 1, 2.0)
                                                                                        ^~~

解答 #

1. 代码中的错误点 #

• 类型变量定义错误：重复定义_T，第二个_T应为_U；且错误将_T和_U绑定到type（表示类型本身），但实际需要的是参数/返回值的实例类型，而非类型对象。
• Protocol类型标注错误：CTypesCallable的argtypes和__call__参数标注逻辑混乱，_T被绑定为type，导致实际传入的实例（如SomePythonType()）与类型检查期望的type不匹配。
• ctypes核心属性未设置：原代码未给获取到的ctypes函数设置argtypes和restype，这不仅会触发类型检查错误，运行时也可能出现参数/返回值的类型转换异常。
• 默认返回值类型不兼容：当ret_type为None时，赋值ctypes.c_uint（类型对象），但_U被绑定为type，与实际返回的c_uint实例类型不匹配。

2. 简化方案与过度设计判断 #

当前方案存在过度设计：如果前后处理逻辑不是必需的，完全不需要额外封装CTypesFunction类，直接对ctypes函数设置类型属性并添加类型标注即可。

简化后的实现（保留前后处理）

import ctypes
from collections.abc import Sequence
from typing import (
    TypeVar, Protocol, Generic, Optional, cast as TYPE_CAST
)

# _T表示参数实例类型，_U表示返回值实例类型
_T = TypeVar('_T')
_U = TypeVar('_U', covariant=True)

class CTypesCallable(Protocol[_T, _U]):
    __name__: str
    argtypes: Sequence[type]
    restype: type

    def __call__(self, *args: _T) -> _U: ...

class CTypesFunction(Generic[_T, _U]):
    def __init__(self, function: CTypesCallable[_T, _U]) -> None:
        self.function = function

    def __call__(self, *args: _T) -> _U:
        # 预处理/参数验证逻辑
        ret = self.function(*args)
        # 后处理/返回值验证逻辑
        return ret

def get_ctypes_func(
    name: str,
    arg_types: Sequence[type],
    ret_type: Optional[type[_U]] = None
) -> CTypesFunction[_T, _U]:
    ret_type = ret_type or ctypes.c_uint
    func = getattr(some_c_lib, name)
    # 必须设置argtypes和restype，保证ctypes类型转换和类型检查正确
    func.argtypes = arg_types
    func.restype = ret_type
    return CTypesFunction(TYPE_CAST(CTypesCallable[_T, _U], func))

极致简化版（无前后处理）

import ctypes
from collections.abc import Sequence
from typing import TypeVar, Protocol, Optional, cast as TYPE_CAST

_T = TypeVar('_T')
_U = TypeVar('_U')

class CTypesFunc(Protocol[_T, _U]):
    def __call__(self, *args: _T) -> _U: ...

def get_ctypes_func(
    name: str,
    arg_types: Sequence[type],
    ret_type: Optional[type[_U]] = None
) -> CTypesFunc[_T, _U]:
    ret_type = ret_type or ctypes.c_uint
    func = getattr(some_c_lib, name)
    func.argtypes = arg_types
    func.restype = ret_type
    return TYPE_CAST(CTypesFunc[_T, _U], func)

3. Python版本兼容性 #

• Python 3.8完全可行：3.8已支持Protocol、TypeVar、Generic等核心类型标注特性，虽然没有Python 3.10+的ParamSpec（无法精确标注不同类型的可变参数），但可以通过*args: _T适配，或者针对固定参数个数的函数做重载（如需更精确的类型检查）。
• 更低版本限制：Python 3.5-3.7不支持原生Protocol，需要借助typing_extensions库的Protocol才能实现静态类型检查；Python 2.x完全不支持现代类型标注体系，无法实现类似的静态类型约束。

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