Can I generate C bindings with pyo3?

[RaulTrombin]

Hey there!

I want to make some drivers for rust using i2c/spi, but I want them to have C and Python bindings.

To test this idea, I started with a simple example: creating a file and reading it. Here's the code: https://pastebin.com/8wH5Vk5f

I managed to bind it to Python using pyo3, but I still need a solution for the C bindings. Do you know if I can find it on pyo3?

I came across these articles where the author created a binding for C and then for python:
https://developers.redhat.com/articles/2022/09/05/how-create-python-binding-rust-library#
https://github.com/cathay4t/librabc
But not so familiar with it yet

[adamreichold]

I think the C bindings would be developed independently of the Python bindings and PyO3. Generally speaking, you would create a Rust-native core library and then put PyO3-based Python bindings on top of it. Similarly, C bindings would be put on top of the same core library.

Writing C bindings for Rust is more or less an independent endeavour, but basically you would need to provide #[no_mangle] pub extern "C" fn entry points and providing C headers manually or optionally using cbindgen.

[RaulTrombin]

Thanks for repply, I did some experiment with cbindgen,
But from cbindgen now I can import the c files to python.

Example calling c bindings:

import sys
import ctypes

lib=ctypes.CDLL("target/debug/liblog_txt_c.so")
lib.append_to_file("log.txt","niiiiiiiiiiiiiidilwi")
print(lib.read_from_file("log.txt"))

project structure:

.
├── README.md
└── rust_txt_project
    ├── log_txt_c
    │   ├── Cargo.lock
    │   ├── Cargo.toml
    │   ├── cbindgen.toml
    │   ├── README.md
    │   └── src
    │       ├── build.rs
    │       └── lib.rs
    ├── log_txt_py
    │   ├── Cargo.lock
    │   ├── Cargo.toml
    │   ├── pyproject.toml
    │   ├── README.md
    │   └── src
    │       └── lib.rs
    └── rust_txt_core
        ├── Cargo.lock
        ├── Cargo.toml
        └── src
            └── lib.rs

Is there some advantage using pyo3 instead the cbindings import?

[davidhewitt]

With ctypes you're restricted to the constructs which exist in the C language, and you likely need to add a wrapper around them as Python code if you want to create an experience in Python which feels like native Python experience.

With PyO3 you are building "extension modules" which implement Python language functionality via exactly the same mechanism that fundamental modules like datetime are implemented. So you can create a much richer interface for Python users directly from Rust.

[RaulTrombin]

@davidhewitt i've tried something here:
https://github.com/RaulTrombin/rust-studies/tree/main/rust_txt_project
It's just a rust program that create, write and read a file. I did a port to python and c.

Some updates, my collegue made a way more refinated program that outputs both bindings:
https://github.com/patrickelectric/rust-binds