Merge pull request #336 from PyO3/rust_2018

Migrate to rust 2018

Author: konstin

.gitignore

@@ -14,7 +14,7 @@ dist/
 .eggs/
 venv*
 guide/book/
-examples/*/py
+examples/*/py*
 
 *.so
 *.out

CHANGELOG.md

@@ -8,13 +8,16 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Added
 
- * Added a `wrap_module!` macro similar to the existing `wrap_function!` macro. Only available on python 3
+ * Added a `wrap_pymodule!` macro similar to the existing `wrap_pyfunction!` macro. Only available on python 3
+ * Added support for cross compiling (e.g. to arm v7) by mtp401 in [#327](https://github.com/PyO3/pyo3/pull/327). See the "Cross Compiling" section in the "Building and Distribution" chapter of the guide for more details.
 
 ### Changed
 
  * Renamed `add_function` to `add_wrapped` as it now also supports modules.
  * Renamed `#[pymodinit]` to `#[pymodule]`.
  * Renamed `py_exception` to `create_exception` and refactored the error macros.
+ * Renamed `wrap_function!` to `wrap_pyfunction!`
+ * Migrated to the 2018 edition
 
 ### Removed
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pyo3"
-version = "0.6.0-alpha.1"
+version = "0.6.0-alpha.2"
 description = "Bindings to Python interpreter"
 authors = ["PyO3 Project and Contributors <https://github.com/PyO3>"]
 readme = "README.md"
@@ -12,6 +12,7 @@ categories = ["api-bindings", "development-tools::ffi"]
 license = "Apache-2.0"
 exclude = ["/.gitignore", ".travis.yml", ".cargo/config", "appveyor.yml"]
 build = "build.rs"
+edition = "2018"
 
 [badges]
 travis-ci = { repository = "PyO3/pyo3", branch = "master" }
@@ -22,7 +23,7 @@ codecov = { repository = "PyO3/pyo3", branch = "master", service = "github" }
 libc = "0.2.43"
 spin = "0.5.0"
 num-traits = "0.2.6"
-pyo3cls = { path = "pyo3cls", version = "=0.6.0-alpha.1" }
+pyo3cls = { path = "pyo3cls", version = "=0.6.0-alpha.2" }
 mashup = "0.1.9"
 num-complex = { version = "0.2.1", optional = true }
 

README.md

@@ -31,19 +31,20 @@ sudo apt install python3-dev python-dev
 
 Pyo3 can be used to generate a native python module.
 
-**`Cargo.toml`:**
+**`Cargo.toml`**
 
 ```toml
 [package]
 name = "string-sum"
 version = "0.1.0"
+edition = "2018"
 
 [lib]
 name = "string_sum"
 crate-type = ["cdylib"]
 
 [dependencies.pyo3]
-version = "0.6.0-alpha.1"
+version = "0.6.0-alpha.2"
 features = ["extension-module"]
 ```
 
@@ -52,10 +53,8 @@ features = ["extension-module"]
 ```rust
 #![feature(specialization)]
 
-#[macro_use]
-extern crate pyo3;
-
 use pyo3::prelude::*;
+use pyo3::wrap_pyfunction;
 
 #[pyfunction]
 /// Formats the sum of two numbers as string
@@ -66,7 +65,7 @@ fn sum_as_string(a: usize, b: usize) -> PyResult<String> {
 /// This module is a python module implemented in Rust.
 #[pymodule]
 fn string_sum(py: Python, m: &PyModule) -> PyResult<()> {
-    m.add_wrapped(wrap_function!(sum_as_string))?;
+    m.add_wrapped(wrap_pyfunction!(sum_as_string))?;
 
     Ok(())
 }
@@ -92,16 +91,14 @@ Add `pyo3` this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-pyo3 = "0.5"
+pyo3 = "0.6.0-alpha.2"
 ```
 
 Example program displaying the value of `sys.version`:
 
 ```rust
 #![feature(specialization)]
 
-extern crate pyo3;
-
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
@@ -110,11 +107,10 @@ fn main() -> PyResult<()> {
     let py = gil.python();
     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()?;
-
+    let code = "os.getenv('USER') or os.getenv('USERNAME') or 'Unknown'";
+    let user: String = py.eval(code, None, Some(&locals))?.extract()?;
     println!("Hello {}, I'm Python {}", user, version);
     Ok(())
 }

benches/bench_dict.rs

@@ -1,10 +1,10 @@
 #![feature(test)]
-extern crate pyo3;
+
 extern crate test;
+use pyo3::prelude::*;
+use pyo3::types::IntoPyDict;
 use test::Bencher;
 
-use pyo3::{prelude::*, types::IntoPyDict};
-
 #[bench]
 fn iter_dict(b: &mut Bencher) {
     let gil = Python::acquire_gil();

ci/travis/test.sh

@@ -2,8 +2,8 @@
 set -ex
 
 cargo fmt --all -- --check
-cargo test --features "$FEATURES"
-cargo clippy --features "$FEATURES"
+cargo test --features "$FEATURES num-complex"
+cargo clippy --features "$FEATURES num-complex"
 
 for example_dir in examples/*; do
     tox -c "$example_dir/tox.ini" -e py

examples/rustapi_module/Cargo.toml

@@ -3,6 +3,7 @@ authors = ["PyO3 Authors"]
 name = "rustapi-module"
 version = "0.1.0"
 description = "A Python wrapper for the Rust API for purposes of testing"
+edition = "2018"
 
 [dependencies]
 

examples/rustapi_module/src/datetime.rs

@@ -3,28 +3,29 @@ use pyo3::types::{
     PyDate, PyDateAccess, PyDateTime, PyDelta, PyDeltaAccess, PyTime, PyTimeAccess, PyTuple,
     PyTzInfo,
 };
+use pyo3::wrap_pyfunction;
 
 #[pyfunction]
-fn make_date(py: Python, year: i32, month: u8, day: u8) -> PyResult<Py<PyDate>> {
+fn make_date(py: Python<'_>, year: i32, month: u8, day: u8) -> PyResult<Py<PyDate>> {
     PyDate::new(py, year, month, day)
 }
 
 #[pyfunction]
-fn get_date_tuple(py: Python, d: &PyDate) -> Py<PyTuple> {
+fn get_date_tuple(py: Python<'_>, d: &PyDate) -> Py<PyTuple> {
     PyTuple::new(
         py,
         &[d.get_year(), d.get_month() as i32, d.get_day() as i32],
     )
 }
 
 #[pyfunction]
-fn date_from_timestamp(py: Python, timestamp: i64) -> PyResult<Py<PyDate>> {
+fn date_from_timestamp(py: Python<'_>, timestamp: i64) -> PyResult<Py<PyDate>> {
     PyDate::from_timestamp(py, timestamp)
 }
 
 #[pyfunction]
 fn make_time(
-    py: Python,
+    py: Python<'_>,
     hour: u8,
     minute: u8,
     second: u8,
@@ -64,7 +65,7 @@ fn time_with_fold(
 }
 
 #[pyfunction]
-fn get_time_tuple(py: Python, dt: &PyTime) -> Py<PyTuple> {
+fn get_time_tuple(py: Python<'_>, dt: &PyTime) -> Py<PyTuple> {
     PyTuple::new(
         py,
         &[
@@ -92,12 +93,12 @@ fn get_time_tuple_fold(py: Python, dt: &PyTime) -> Py<PyTuple> {
 }
 
 #[pyfunction]
-fn make_delta(py: Python, days: i32, seconds: i32, microseconds: i32) -> PyResult<Py<PyDelta>> {
+fn make_delta(py: Python<'_>, days: i32, seconds: i32, microseconds: i32) -> PyResult<Py<PyDelta>> {
     PyDelta::new(py, days, seconds, microseconds, true)
 }
 
 #[pyfunction]
-fn get_delta_tuple(py: Python, delta: &PyDelta) -> Py<PyTuple> {
+fn get_delta_tuple(py: Python<'_>, delta: &PyDelta) -> Py<PyTuple> {
     PyTuple::new(
         py,
         &[
@@ -110,7 +111,7 @@ fn get_delta_tuple(py: Python, delta: &PyDelta) -> Py<PyTuple> {
 
 #[pyfunction]
 fn make_datetime(
-    py: Python,
+    py: Python<'_>,
     year: i32,
     month: u8,
     day: u8,
@@ -134,7 +135,7 @@ fn make_datetime(
 }
 
 #[pyfunction]
-fn get_datetime_tuple(py: Python, dt: &PyDateTime) -> Py<PyTuple> {
+fn get_datetime_tuple(py: Python<'_>, dt: &PyDateTime) -> Py<PyTuple> {
     PyTuple::new(
         py,
         &[
@@ -168,7 +169,11 @@ fn get_datetime_tuple_fold(py: Python, dt: &PyDateTime) -> Py<PyTuple> {
 }
 
 #[pyfunction]
-fn datetime_from_timestamp(py: Python, ts: f64, tz: Option<&PyTzInfo>) -> PyResult<Py<PyDateTime>> {
+fn datetime_from_timestamp(
+    py: Python<'_>,
+    ts: f64,
+    tz: Option<&PyTzInfo>,
+) -> PyResult<Py<PyDateTime>> {
     PyDateTime::from_timestamp(py, ts, tz)
 }
 
@@ -189,41 +194,41 @@ impl TzClass {
         obj.init(|| TzClass {})
     }
 
-    fn utcoffset(&self, py: Python, _dt: &PyDateTime) -> PyResult<Py<PyDelta>> {
+    fn utcoffset(&self, py: Python<'_>, _dt: &PyDateTime) -> PyResult<Py<PyDelta>> {
         PyDelta::new(py, 0, 3600, 0, true)
     }
 
-    fn tzname(&self, _py: Python, _dt: &PyDateTime) -> PyResult<String> {
+    fn tzname(&self, _py: Python<'_>, _dt: &PyDateTime) -> PyResult<String> {
         Ok(String::from("+01:00"))
     }
 
-    fn dst(&self, _py: Python, _dt: &PyDateTime) -> PyResult<Option<&PyDelta>> {
+    fn dst(&self, _py: Python<'_>, _dt: &PyDateTime) -> PyResult<Option<&PyDelta>> {
         Ok(None)
     }
 }
 
 #[pymodule]
-fn datetime(_py: Python, m: &PyModule) -> PyResult<()> {
-    m.add_wrapped(wrap_function!(make_date))?;
-    m.add_wrapped(wrap_function!(get_date_tuple))?;
-    m.add_wrapped(wrap_function!(date_from_timestamp))?;
-    m.add_wrapped(wrap_function!(make_time))?;
-    m.add_wrapped(wrap_function!(get_time_tuple))?;
-    m.add_wrapped(wrap_function!(make_delta))?;
-    m.add_wrapped(wrap_function!(get_delta_tuple))?;
-    m.add_wrapped(wrap_function!(make_datetime))?;
-    m.add_wrapped(wrap_function!(get_datetime_tuple))?;
-    m.add_wrapped(wrap_function!(datetime_from_timestamp))?;
+fn datetime(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(make_date))?;
+    m.add_wrapped(wrap_pyfunction!(get_date_tuple))?;
+    m.add_wrapped(wrap_pyfunction!(date_from_timestamp))?;
+    m.add_wrapped(wrap_pyfunction!(make_time))?;
+    m.add_wrapped(wrap_pyfunction!(get_time_tuple))?;
+    m.add_wrapped(wrap_pyfunction!(make_delta))?;
+    m.add_wrapped(wrap_pyfunction!(get_delta_tuple))?;
+    m.add_wrapped(wrap_pyfunction!(make_datetime))?;
+    m.add_wrapped(wrap_pyfunction!(get_datetime_tuple))?;
+    m.add_wrapped(wrap_pyfunction!(datetime_from_timestamp))?;
 
     // Python 3.6+ functions
     #[cfg(Py_3_6)]
     {
-        m.add_wrapped(wrap_function!(time_with_fold))?;
-        m.add_wrapped(wrap_function!(get_time_tuple_fold))?;
-        m.add_wrapped(wrap_function!(get_datetime_tuple_fold))?;
+        m.add_wrapped(wrap_pyfunction!(time_with_fold))?;
+        m.add_wrapped(wrap_pyfunction!(get_time_tuple_fold))?;
+        m.add_wrapped(wrap_pyfunction!(get_datetime_tuple_fold))?;
     }
 
-    m.add_wrapped(wrap_function!(issue_219))?;
+    m.add_wrapped(wrap_pyfunction!(issue_219))?;
 
     m.add_class::<TzClass>()?;
     Ok(())

examples/rustapi_module/src/dict_iter.rs

@@ -1,10 +1,9 @@
-use pyo3::prelude::*;
-
 use pyo3::exceptions::RuntimeError;
+use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
 #[pymodule]
-fn test_dict(_py: Python, m: &PyModule) -> PyResult<()> {
+fn test_dict(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_class::<DictSize>()?;
     Ok(())
 }
@@ -21,7 +20,7 @@ impl DictSize {
         obj.init(|| DictSize { expected })
     }
 
-    fn iter_dict(&mut self, _py: Python, dict: &PyDict) -> PyResult<u32> {
+    fn iter_dict(&mut self, _py: Python<'_>, dict: &PyDict) -> PyResult<u32> {
         let mut seen = 0u32;
         for (sym, values) in dict.iter() {
             seen += 1;

examples/rustapi_module/src/lib.rs

@@ -1,8 +1,5 @@
 #![feature(specialization)]
 
-#[macro_use]
-extern crate pyo3;
-
 pub mod datetime;
 pub mod dict_iter;
 pub mod othermod;

examples/rustapi_module/src/othermod.rs

@@ -3,6 +3,7 @@
 //! The code below just tries to use the most important code generation paths
 
 use pyo3::prelude::*;
+use pyo3::wrap_pyfunction;
 
 #[pyclass]
 pub struct ModClass {
@@ -29,8 +30,8 @@ fn double(x: i32) -> i32 {
 }
 
 #[pymodule]
-fn othermod(_py: Python, m: &PyModule) -> PyResult<()> {
-    m.add_wrapped(wrap_function!(double))?;
+fn othermod(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
+    m.add_wrapped(wrap_pyfunction!(double))?;
     m.add_class::<ModClass>()?;
 
     m.add("USIZE_MIN", usize::min_value())?;

examples/rustapi_module/src/subclassing.rs

@@ -14,7 +14,7 @@ impl Subclassable {
 }
 
 #[pymodule]
-fn subclassing(_py: Python, m: &PyModule) -> PyResult<()> {
+fn subclassing(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_class::<Subclassable>()?;
     Ok(())
 }

examples/word-count/Cargo.toml

@@ -2,6 +2,7 @@
 authors = ["Messense Lv <[email protected]>"]
 name = "word-count"
 version = "0.1.0"
+edition = "2018"
 
 [dependencies]
 rayon = "1.0.2"