| """ |
| Build a c-extension module on-the-fly in tests. |
| See build_and_import_extensions for usage hints |
| |
| """ |
|
|
| import os |
| import pathlib |
| import subprocess |
| import sys |
| import sysconfig |
| import textwrap |
|
|
| __all__ = ['build_and_import_extension', 'compile_extension_module'] |
|
|
|
|
| def build_and_import_extension( |
| modname, functions, *, prologue="", build_dir=None, |
| include_dirs=None, more_init=""): |
| """ |
| Build and imports a c-extension module `modname` from a list of function |
| fragments `functions`. |
| |
| |
| Parameters |
| ---------- |
| functions : list of fragments |
| Each fragment is a sequence of func_name, calling convention, snippet. |
| prologue : string |
| Code to precede the rest, usually extra ``#include`` or ``#define`` |
| macros. |
| build_dir : pathlib.Path |
| Where to build the module, usually a temporary directory |
| include_dirs : list |
| Extra directories to find include files when compiling |
| more_init : string |
| Code to appear in the module PyMODINIT_FUNC |
| |
| Returns |
| ------- |
| out: module |
| The module will have been loaded and is ready for use |
| |
| Examples |
| -------- |
| >>> functions = [("test_bytes", "METH_O", \"\"\" |
| if ( !PyBytesCheck(args)) { |
| Py_RETURN_FALSE; |
| } |
| Py_RETURN_TRUE; |
| \"\"\")] |
| >>> mod = build_and_import_extension("testme", functions) |
| >>> assert not mod.test_bytes('abc') |
| >>> assert mod.test_bytes(b'abc') |
| """ |
| if include_dirs is None: |
| include_dirs = [] |
| body = prologue + _make_methods(functions, modname) |
| init = """ |
| PyObject *mod = PyModule_Create(&moduledef); |
| #ifdef Py_GIL_DISABLED |
| PyUnstable_Module_SetGIL(mod, Py_MOD_GIL_NOT_USED); |
| #endif |
| """ |
| if not build_dir: |
| build_dir = pathlib.Path('.') |
| if more_init: |
| init += """#define INITERROR return NULL |
| """ |
| init += more_init |
| init += "\nreturn mod;" |
| source_string = _make_source(modname, init, body) |
| mod_so = compile_extension_module( |
| modname, build_dir, include_dirs, source_string) |
| import importlib.util |
| spec = importlib.util.spec_from_file_location(modname, mod_so) |
| foo = importlib.util.module_from_spec(spec) |
| spec.loader.exec_module(foo) |
| return foo |
|
|
|
|
| def compile_extension_module( |
| name, builddir, include_dirs, |
| source_string, libraries=None, library_dirs=None): |
| """ |
| Build an extension module and return the filename of the resulting |
| native code file. |
| |
| Parameters |
| ---------- |
| name : string |
| name of the module, possibly including dots if it is a module inside a |
| package. |
| builddir : pathlib.Path |
| Where to build the module, usually a temporary directory |
| include_dirs : list |
| Extra directories to find include files when compiling |
| libraries : list |
| Libraries to link into the extension module |
| library_dirs: list |
| Where to find the libraries, ``-L`` passed to the linker |
| """ |
| modname = name.split('.')[-1] |
| dirname = builddir / name |
| dirname.mkdir(exist_ok=True) |
| cfile = _convert_str_to_file(source_string, dirname) |
| include_dirs = include_dirs or [] |
| libraries = libraries or [] |
| library_dirs = library_dirs or [] |
|
|
| return _c_compile( |
| cfile, outputfilename=dirname / modname, |
| include_dirs=include_dirs, libraries=libraries, |
| library_dirs=library_dirs, |
| ) |
|
|
|
|
| def _convert_str_to_file(source, dirname): |
| """Helper function to create a file ``source.c`` in `dirname` that contains |
| the string in `source`. Returns the file name |
| """ |
| filename = dirname / 'source.c' |
| with filename.open('w') as f: |
| f.write(str(source)) |
| return filename |
|
|
|
|
| def _make_methods(functions, modname): |
| """ Turns the name, signature, code in functions into complete functions |
| and lists them in a methods_table. Then turns the methods_table into a |
| ``PyMethodDef`` structure and returns the resulting code fragment ready |
| for compilation |
| """ |
| methods_table = [] |
| codes = [] |
| for funcname, flags, code in functions: |
| cfuncname = f"{modname}_{funcname}" |
| if 'METH_KEYWORDS' in flags: |
| signature = '(PyObject *self, PyObject *args, PyObject *kwargs)' |
| else: |
| signature = '(PyObject *self, PyObject *args)' |
| methods_table.append( |
| "{\"%s\", (PyCFunction)%s, %s}," % (funcname, cfuncname, flags)) |
| func_code = f""" |
| static PyObject* {cfuncname}{signature} |
| {{ |
| {code} |
| }} |
| """ |
| codes.append(func_code) |
|
|
| body = "\n".join(codes) + """ |
| static PyMethodDef methods[] = { |
| %(methods)s |
| { NULL } |
| }; |
| static struct PyModuleDef moduledef = { |
| PyModuleDef_HEAD_INIT, |
| "%(modname)s", /* m_name */ |
| NULL, /* m_doc */ |
| -1, /* m_size */ |
| methods, /* m_methods */ |
| }; |
| """ % {'methods': '\n'.join(methods_table), 'modname': modname} |
| return body |
|
|
|
|
| def _make_source(name, init, body): |
| """ Combines the code fragments into source code ready to be compiled |
| """ |
| code = """ |
| #include <Python.h> |
| |
| %(body)s |
| |
| PyMODINIT_FUNC |
| PyInit_%(name)s(void) { |
| %(init)s |
| } |
| """ % { |
| 'name': name, 'init': init, 'body': body, |
| } |
| return code |
|
|
|
|
| def _c_compile(cfile, outputfilename, include_dirs, libraries, |
| library_dirs): |
| link_extra = [] |
| if sys.platform == 'win32': |
| compile_extra = ["/we4013"] |
| link_extra.append('/DEBUG') |
| elif sys.platform.startswith('linux'): |
| compile_extra = [ |
| "-O0", "-g", "-Werror=implicit-function-declaration", "-fPIC"] |
| else: |
| compile_extra = [] |
|
|
| return build( |
| cfile, outputfilename, |
| compile_extra, link_extra, |
| include_dirs, libraries, library_dirs) |
|
|
|
|
| def build(cfile, outputfilename, compile_extra, link_extra, |
| include_dirs, libraries, library_dirs): |
| "use meson to build" |
|
|
| build_dir = cfile.parent / "build" |
| os.makedirs(build_dir, exist_ok=True) |
| with open(cfile.parent / "meson.build", "wt") as fid: |
| link_dirs = ['-L' + d for d in library_dirs] |
| fid.write(textwrap.dedent(f"""\ |
| project('foo', 'c') |
| py = import('python').find_installation(pure: false) |
| py.extension_module( |
| '{outputfilename.parts[-1]}', |
| '{cfile.parts[-1]}', |
| c_args: {compile_extra}, |
| link_args: {link_dirs}, |
| include_directories: {include_dirs}, |
| ) |
| """)) |
| native_file_name = cfile.parent / ".mesonpy-native-file.ini" |
| with open(native_file_name, "wt") as fid: |
| fid.write(textwrap.dedent(f"""\ |
| [binaries] |
| python = '{sys.executable}' |
| """)) |
| if sys.platform == "win32": |
| subprocess.check_call(["meson", "setup", |
| "--buildtype=release", |
| "--vsenv", ".."], |
| cwd=build_dir, |
| ) |
| else: |
| subprocess.check_call(["meson", "setup", "--vsenv", |
| "..", f'--native-file={os.fspath(native_file_name)}'], |
| cwd=build_dir |
| ) |
|
|
| so_name = outputfilename.parts[-1] + get_so_suffix() |
| subprocess.check_call(["meson", "compile"], cwd=build_dir) |
| os.rename(str(build_dir / so_name), cfile.parent / so_name) |
| return cfile.parent / so_name |
|
|
|
|
| def get_so_suffix(): |
| ret = sysconfig.get_config_var('EXT_SUFFIX') |
| assert ret |
| return ret |
|
|
