Python C 扩展将 Capsule 暴露给 ctypes 以使用第三方 C 代码

Question

我有一个 Python C 扩展，它包装了专有产品的库。我们公司有大量使用专有产品的C代码。我认为我可以简单地将 Capsule 返回到 Python 土地，并允许我的库的用户使用 ctypes 包装一些 C 函数，而不是使用我的 C 扩展在 Python 中重写它。

这是一种有效的方法吗？还有更好的吗？

这里有一些代码来说明我的方法。

我的 Python C 扩展:

typedef struct {
    PyObject_HEAD

    Foo *foo; /* The proprietary data structure we are wrapping */
} PyFoo;

/*
* Expose a pointer to Foo such that ctypes can use it
*/
static PyObject PyFoo_capsule(PyFoo *self, PyObject *args, PyObject *kwargs)
{
     return PyCapsule_New(self->foo, "foo", NULL);
}

以下是我们团队编写的一些预先存在的 C 代码，并希望从 Python 调用:

void print_foo(Foo *foo)
{
    Foo_print(foo);
}

在Python中，我们可以用ctypes包装第三方C代码(我学到了这个here):

import pyfoo
import ctypes

foo = pyfoo.Foo()
capsule = foo.capsule()

ctypes.pythonapi.PyCapsule_GetPointer.restype = ctypes.c_void_p
ctypes.pythonapi.PyCapsule_GetPointer.argtypes = [ctypes.py_object, ctypes.c_char_p]
pointer = ctypes.pythonapi.PyCapsule_GetPointer(
    capsule, 
    ctypes.create_string_buffer("foo".encode())
)

libfoo = ctypes.CDLL('libfoo.so')
libfoo.print_foo.restype = None
libfoo.print_foo.argtypes = [ctypes.POINTER(None)]
libfoo.print_foo(pointer)

Answer 1

它会起作用，但我不喜欢将 void* 用于不透明类型的方法，因为任何 void* 都可以，而在 C 端，类型很重要，如果传递了指向错误类型的指针，则您的诊断很可能是段错误(或更糟)。

大多数(自动)绑定(bind)器(用于 C/C++ 的 SWIG、pybind11、cppyy 或用于 C 的 CFFI)将为不透明的 C/C++ 绑定(bind)器生成 Python 类型，以允许类型匹配。

这是一个 cppyy ( http://cppyy.org ) 示例，假设文件 foo.h 如下所示:

struct Foo;
struct Bar;

typedef Foo* FOOHANDLE;
typedef Bar* BARHANDLE;

void use_foo(FOOHANDLE);
void use_bar(BARHANDLE);

和一些匹配的库libfoo.so，那么当从cppyy使用时，您只能通过FOOHANDLE参数等传递FOOHANDLE，这样您就可以获得干净的Python端回溯，而不是C侧面碰撞。 session 示例:

>>> import cppyy
>>> cppyy.c_include("foo.h")     # assumes C, otherwise use 'include'
>>> cppyy.load_library("libfoo")
>>> foo = cppyy.gbl.FOOHANDLE()  # nullptr; can also take an address
>>> cppyy.gbl.use_foo(foo)       # works fine
>>> cppyy.gbl.use_bar(foo)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: void ::use_bar(Bar*) =>
    TypeError: could not convert argument 1
>>> 

编辑:通过一些工作，可以使用 ctypes 完成相同的操作，如下所示，因此如果您公开返回 self->foo 的 C 函数作为 Foo*，您同样可以使用 Python FOOHANDLE 注释其 restype，从而绕过胶囊并保持类型安全:

import ctypes

libfoo = ctypes.CDLL('./libfoo.so')

class Foo(ctypes.Structure):
    _fields_ = []

FOOHANDLE = ctypes.POINTER(Foo)

class Bar(ctypes.Structure):
    _fields_ = []

BARHANDLE = ctypes.POINTER(Bar)

libfoo.use_foo.restype = None
libfoo.use_foo.argtypes = [FOOHANDLE]

libfoo.use_bar.restype = None
libfoo.use_bar.argtypes = [BARHANDLE]

foo = FOOHANDLE()

libfoo.use_foo(foo)  # succeeds
libfoo.use_bar(foo)  # proper python TypeError