pyo3 0.2.7

Bindings to Python interpreter failed to build pyo3-0.2.7
Please check build logs and if you believe this is' fault, report into this issue report.

PyO3 Build Status Build Status codecov Join the dev chat

Rust bindings for the Python interpreter.

PyO3 is licensed under the Apache-2.0 license. Python is licensed under the Python License.

Supported Python versions:

  • Python 2.7, Python 3.5 and up

Supported Rust version:

  • Rust 1.27.0-nightly 2018-05-01 or later


To use pyo3, add this to your Cargo.toml:

pyo3 = "0.2"

Example program displaying the value of sys.version:

extern crate pyo3;

use pyo3::{Python, PyDict, PyResult, ObjectProtocol};

fn main() {
    let gil = Python::acquire_gil();

fn hello(py: Python) -> PyResult<()> {
    let sys = py.import("sys")?;
    let version: String = sys.get("version")?.extract()?;

    let locals = PyDict::new(py);
    locals.set_item("os", py.import("os")?)?;
    let user: String = py.eval("os.getenv('USER') or os.getenv('USERNAME')", None, Some(&locals))?.extract()?;

    println!("Hello {}, I'm Python {}", user, version);

Example library with python bindings:

The following two files will build with cargo build, and will generate a python-compatible library. For MacOS, "-C link-arg=-undefined -C link-arg=dynamic_lookup" is required to build the library. setuptools-rust includes this by default. See examples/word-count and the associated Also on macOS, you will need to rename the output from *.dylib to *.so. On Windows, you will need to rename the output from *.dll to *.pyd.


name = "rust2py"
crate-type = ["cdylib"]

version = "0.2"
features = ["extension-module"]


#![feature(proc_macro, specialization)]

extern crate pyo3;
use pyo3::prelude::*;

use pyo3::py::modinit as pymodinit;

// add bindings to the generated python module
// N.B: names: "librust2py" must be the name of the `.so` or `.pyd` file
/// This module is implemented in Rust.
fn init_mod(py: Python, m: &PyModule) -> PyResult<()> {

    #[pyfn(m, "sum_as_string")]
    // pyo3 aware function. All of our python interface could be declared in a separate module.
    // Note that the `#[pyfn()]` annotation automatically converts the arguments from
    // Python objects to Rust values; and the Rust return value back into a Python object.
    fn sum_as_string_py(a:i64, b:i64) -> PyResult<String> {
       let out = sum_as_string(a, b);


// logic implemented as a normal rust function
fn sum_as_string(a:i64, b:i64) -> String {
    format!("{}", a + b).to_string()

For integration, see setuptools-rust

This is fork of rust-cpython project

Motivation for fork