PythonをZigでスピードアップする

#define PY_SSIZE_T_CLEAN
#include <Python.h>

static PyObject *
zaml_load(PyObject *self, PyObject *args)
{
    return Py_BuildValue("i", 1);
}

static PyMethodDef ZamlMethods[] = {
    {.ml_name = "load",
     .ml_meth = zaml_load,
     .ml_flags = METH_NOARGS,
     .ml_doc = "Load some tasty YAML."},

    {.ml_name = NULL,
     .ml_meth = NULL,
     .ml_flags = 0,
     .ml_doc = NULL}, /* Sentinel */
};

static struct PyModuleDef zamlmodule = {
    .m_base = PyModuleDef_HEAD_INIT,
    .m_name = "zaml", /* name of module */
    .m_doc = NULL,    /* module documentation, may be NULL */
    .m_size = -1,     /* size of per-interpreter state of the module,
                         or -1 if the module keeps state in global variables.  */
    .m_methods = ZamlMethods,
    .m_slots = NULL,
    .m_traverse = NULL,
    .m_clear = NULL,
    .m_free = NULL,
};

PyMODINIT_FUNC
PyInit_zaml(void)
{
    return PyModule_Create(&zamlmodule);
}

from setuptools import setup, Extension

zaml = Extension("zaml", sources=["zamlmodule.c"])

setup(
    name="zaml",
    version="0.0.1",
    description="Fast YAML 1.2 Parser for Python 3.10.x",
    ext_modules=[zaml],
)

$ pip install -e .
Obtaining file:///work
Installing collected packages: zaml
  Running setup.py develop for zaml
Successfully installed zaml```
$ ipython
In [1]: import zaml

In [2]: zaml.load()
Out[2]: 1

const py = @cImport({
    @cDefine("PYSSIZE_T_CLEAN", {});
    @cInclude("Python.h");
});

const PyObject = py.PyObject;
const PyMethodDef = py.PyMethodDef;
const PyModuleDef = py.PyModuleDef;
const PyModuleDef_Base = py.PyModuleDef_Base;
const Py_BuildValue = py.Py_BuildValue;
const PyModule_Create = py.PyModule_Create;
const METH_NOARGS = py.METH_NOARGS;

fn zaml_load(self: ?*PyObject, args: ?*PyObject) callconv(.C) *PyObject {
    _ = self;
    _ = args;
    return Py_BuildValue("i", @as(c_int, 1));
}

var ZamlMethods = [_]PyMethodDef{
    PyMethodDef{
        .ml_name = "load",
        .ml_meth = zaml_load,
        .ml_flags = METH_NOARGS,
        .ml_doc = "Load some tasty YAML.",
    },
    PyMethodDef{
        .ml_name = null,
        .ml_meth = null,
        .ml_flags = 0,
        .ml_doc = null,
    }
};

var zamlmodule = PyModuleDef{
    .m_base = PyModuleDef_Base{
        .ob_base = PyObject{
            .ob_refcnt = 1,
            .ob_type = null,
        },
        .m_init = null,
        .m_index = 0,
        .m_copy = null,
    },
    .m_name = "zaml",
    .m_doc = null,
    .m_size = -1,
    .m_methods = &ZamlMethods,
    .m_slots = null,
    .m_traverse = null,
    .m_clear = null,
    .m_free = null,
};

pub export fn PyInit_zaml() *PyObject {
    return PyModule_Create(&zamlmodule);
}

const std = @import("std");
const ChildProcess = std.ChildProcess;
const EmitOption = std.EmitOption;

pub fn build(b: *std.build.Builder) !void {
    // Find Python header file
    const result = try ChildProcess.exec(.{
        .allocator = std.heap.page_allocator,
        .argv = &[_][]const u8{
            "python",
            "-c",
            "import sysconfig; print(sysconfig.get_path(\"include\"), end=\"\")",
        },
    });
    const includeDir = result.stdout;

    // Standard release options allow the person running `zig build` to select
    // between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
    const mode = b.standardReleaseOptions();

    const lib = b.addSharedLibrary("zaml", "zamlmodule.zig", .unversioned);
    lib.addIncludeDir(includeDir);
    lib.setBuildMode(mode);
    lib.linkage = .dynamic;
    lib.linker_allow_shlib_undefined = true;
    lib.linkSystemLibraryName("c");
    // FIXME: Match the out file of setup.py!!
    // const target = lib.target_info.target;
    // const arch = target.cpu.arch;
    // const os = target.os.tag;
    // const version = target.os.getVersionRange();
    // lib.emit_bin = .{ .emit_to = path };
    lib.install();

    const main_tests = b.addTest("zamlmodule.zig");
    main_tests.addIncludeDir(includeDir);
    main_tests.setBuildMode(mode);

    const test_step = b.step("test", "Run library tests");
    test_step.dependOn(&main_tests.step);
}