Python C 扩展将 Capsule 暴露给 ctypes 以便使用第三方 C 代码
Python C Extension Exposing a Capsule to ctypes in order to use third party C code
我有一个 Python C 扩展,它包装了专有产品的库。我们公司有大量使用专有产品的C代码。与其使用我的 C 扩展在 Python 中重写它,我想我可以简单地 return 一个 Capsule 到 Python 土地,并允许我的库的用户用 ctypes 包装一些 C 函数。
这是一种有效的方法吗?还有更好的吗?
下面是一些代码来说明我的方法。
我的 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)
它会起作用,但我不喜欢对不透明类型使用 void*
的方法,任何 void*
都可以,而在 C 端,类型很重要,你的如果传递了指向错误类型的指针,诊断很可能是段错误(或更糟)。
大多数(自动)绑定器(SWIG、pybind11、C/C++ 的 cppyy 或 C 的 CFFI)将为不透明的 C/C++ 生成 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端崩溃。示例会话:
>>> 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
>>>
EDIT:稍加努力,就可以用 ctypes 完成同样的工作,如下所示,因此如果你公开一个 C 函数 returns self->foo
作为 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
我有一个 Python C 扩展,它包装了专有产品的库。我们公司有大量使用专有产品的C代码。与其使用我的 C 扩展在 Python 中重写它,我想我可以简单地 return 一个 Capsule 到 Python 土地,并允许我的库的用户用 ctypes 包装一些 C 函数。
这是一种有效的方法吗?还有更好的吗?
下面是一些代码来说明我的方法。
我的 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)
它会起作用,但我不喜欢对不透明类型使用 void*
的方法,任何 void*
都可以,而在 C 端,类型很重要,你的如果传递了指向错误类型的指针,诊断很可能是段错误(或更糟)。
大多数(自动)绑定器(SWIG、pybind11、C/C++ 的 cppyy 或 C 的 CFFI)将为不透明的 C/C++ 生成 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端崩溃。示例会话:
>>> 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
>>>
EDIT:稍加努力,就可以用 ctypes 完成同样的工作,如下所示,因此如果你公开一个 C 函数 returns self->foo
作为 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