autopxd2

Automatically generate Cython .pxd declaration files from C/C++ header files.

Overview

autopxd2 parses C and C++ header files and generates Cython .pxd declaration files, enabling you to call native C/C++ libraries from Cython without manually writing boilerplate declarations.

Key features:

• Generates complete .pxd declaration files from C/C++ headers
• Powered by headerkit, with a choice of parser backends: LLVM libclang (supporting LLVM 18–23) or tree-sitter (no system LLVM required)
• Full C++ support: classes, methods, constructors, multiple inheritance, templates, and namespaces
• Automatic system include path detection
• Auto-generates cimport statements for standard library types and bundled stubs
• Cross-platform support (Linux, macOS, Windows)

Supported Features

C Features

C++ Features

Installation

pip install autopxd2

autopxd2 uses headerkit, which vendors official LLVM clang Python bindings for LLVM 18–23 directly. No separate clang or clang2 Python package is needed.

You only need the system libclang shared library (libclang.so, libclang.dylib, or libclang.dll).

If libclang is not already installed on your system, install it via your system package manager:

• macOS: brew install llvm
• Ubuntu/Debian: sudo apt-get install libclang-dev
• Fedora/RHEL: sudo dnf install clang-devel
• Windows: winget install LLVM.LLVM

Or use HeaderKit's built-in installer:

python -m headerkit.install_libclang

See the installation docs for more details.

Alternative: Tree-sitter Backend (No LLVM Dependency)

To parse C and C++ headers without requiring system libclang, install the treesitter extra:

pip install "autopxd2[treesitter]"

Then specify --backend tree-sitter:

autopxd --backend tree-sitter myheader.h myheader.pxd

The tree-sitter backend parses the given file only. Compared to libclang it does not:

• follow #include directives, so declarations from included headers are absent
• extract #define macros as constants
• detect system include paths
• accept --std or --clang-arg (both are rejected with an error)

Quick Start

# Generate a .pxd file from a C header
autopxd myheader.h myheader.pxd

# Parse a C++ header
autopxd --cpp myclass.hpp myclass.pxd

# Add project-specific include directories (system includes are auto-detected)
autopxd -I ./include myheader.h myheader.pxd

# Write to stdout (omit output file or use '-')
autopxd myheader.h > myheader.pxd

# Read from stdin
cat myheader.h | autopxd -

Usage

autopxd [OPTIONS] [INFILE] [OUTFILE]

Options:
  -v, --version                  Print version and exit.
  -b, --backend TEXT             Parser backend (default: auto, using libclang).
  --list-backends                List available backends and exit.
  --json                         JSON output (with --list-backends).
  -q, --quiet                    Suppress warnings.
  --debug / --no-debug           Print debug info to stderr.
  -I, --include-dir <dir>        Add include search path.
  -D, --define <macro>           Define preprocessor macro.
  --allowlist <pattern>          Only emit declarations from files matching pattern.
  --denylist <pattern>           Never emit declarations from files matching pattern.
                                 Wins over --allowlist.
  -w, --whitelist <pattern>      Deprecated alias for --allowlist.
  -x, --cpp                      Parse as C++.
  --std <std>                    Language standard (e.g., c11, c++17).
  --clang-arg <arg>              Pass argument to clang.
  --no-default-includes          Disable system include auto-detection.
  -P, --project-prefix <path>    Treat path as project (not system) for umbrella headers.
  --no-recursive                 Disable recursive parsing of umbrella headers.
  --max-depth <n>                Max recursion depth for umbrella headers (default: 10).
  -h, --help                     Show this message and exit.

By default, declarations from every non-system included header are emitted. --no-recursive confines the output to the input header's own declarations. --allowlist narrows the emitted set in either mode, and --denylist subtracts from it; a file matching both lists is excluded, because deny wins over allow.

Automatic Imports

autopxd2 automatically generates cimport statements for commonly used types when using the libclang backend.

Cython Standard Library Types

When headers use types from C standard library headers, autopxd generates appropriate Cython cimports:

// input.h
#include <stdio.h>
#include <stdint.h>

uint32_t process(FILE *f);

# Generated output
from libc.stdint cimport uint32_t
from libc.stdio cimport FILE

cdef extern from "input.h":
    uint32_t process(FILE* f)

Bundled Stub Types

For types not in Cython's standard library, autopxd provides bundled stub declarations:

// input.h
#include <stdarg.h>

void log_message(const char *fmt, va_list args);

# Generated output
from headerkit.stubs.stdarg cimport va_list

cdef extern from "input.h":
    void log_message(const char* fmt, va_list args)

C++ STL Types

C++ standard library types are automatically imported from libcpp:

// input.hpp
#include <vector>
#include <string>

std::vector<std::string> get_items();

# Generated output
from libcpp.string cimport string
from libcpp.vector cimport vector

cdef extern from "input.hpp":
    vector[string] get_items()

Documentation

Full documentation is available at elijahr.github.io/python-autopxd2.

Docker

A Docker image with libclang pre-installed is available:

docker run --rm -v $(pwd):/work -w /work ghcr.io/elijahr/python-autopxd2 autopxd myheader.h

See Docker Usage for more examples.

Contributing

Contributions are welcome. See CONTRIBUTING.md for development setup and guidelines.

License

MIT License. See LICENSE for details.

Acknowledgments

This project is a fork of python-autopxd by Thiago de Arruda.