luxolus
/
pyo3
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Upgrade from proc_macro to use_extern_macros

This commit is contained in:
konstin 2018-07-18 13:08:05 +02:00
parent dbd74401eb
commit d59bebcc38
27 changed files with 78 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG.md
View File

@ -4,7 +4,8 @@
* Upgraded to syn 0.14 which means much better error messages :tada: * Upgraded to syn 0.14 which means much better error messages :tada:
* 128 bit integer support by [kngwyu](https://github.com/kngwyu) ([#137](https://github.com/PyO3/pyo3/pull/173)) * 128 bit integer support by [kngwyu](https://github.com/kngwyu) ([#137](https://github.com/PyO3/pyo3/pull/173))
* Added `py` prefixes to the proc macros and moved them into the root module. You should just use the plain proc macros, i.e. `#[pyclass]`, `#[pymethods]`, `#[pyproto]`, `#[pyfunction]` and `#[pymodinit]`. This is important because `proc_macro_path_invoc` isn't going to be stabilized soon. * `proc_macro` has been stabilized on nightly ([rust-lang/rust#52081](https://github.com/rust-lang/rust/pull/52081)). This means that we can remove the `proc_macro` feature, but now we need the `use_extern_macros` from the 2018 edition instead.
* All proc macro are now prefixed with `py` and live in the prelude. This means you can use `#[pyclass]`, `#[pymethods]`, `#[pyproto]`, `#[pyfunction]` and `#[pymodinit]` directly, at least after a `use pyo3::prelude::*`. They were also moved into a module called `proc_macro`. You shouldn't use `#[pyo3::proc_macro::pyclass]` or other longer paths in attributes because `proc_macro_path_invoc` isn't going to be stabilized soon.
* Renamed the `base` option in the `pyclass` macro to `extends`. * Renamed the `base` option in the `pyclass` macro to `extends`.
* `#[pymodinit]` uses the function name as module name, unless the name is overrriden with `#[pymodinit(name)]` * `#[pymodinit]` uses the function name as module name, unless the name is overrriden with `#[pymodinit(name)]`
* The guide is now properly versioned. * The guide is now properly versioned.

6
README.md
View File

@ -25,7 +25,7 @@ pyo3 = "0.2"
Example program displaying the value of `sys.version`: Example program displaying the value of `sys.version`:
```rust ```rust
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
@ -69,12 +69,12 @@ features = ["extension-module"]
**`src/lib.rs`** **`src/lib.rs`**
```rust ```rust
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::pymodinit;
// Add bindings to the generated python module // Add bindings to the generated python module
// N.B: names: "librust2py" must be the name of the `.so` or `.pyd` file // N.B: names: "librust2py" must be the name of the `.so` or `.pyd` file

5
build.rs
View File

@ -9,8 +9,9 @@ use std::process::Command;
use version_check::{is_min_date, is_min_version, supports_features}; use version_check::{is_min_date, is_min_version, supports_features};
// Specifies the minimum nightly version needed to compile pyo3. // Specifies the minimum nightly version needed to compile pyo3.
const MIN_DATE: &'static str = "2018-05-01"; // This requirement is due to https://github.com/rust-lang/rust/pull/52081
const MIN_VERSION: &'static str = "1.27.0-nightly"; const MIN_DATE: &'static str = "2018-07-16";
const MIN_VERSION: &'static str = "1.29.0-nightly";
#[derive(Debug)] #[derive(Debug)]
struct PythonVersion { struct PythonVersion {

3
examples/word-count-cls/src/lib.rs
View File

@ -1,12 +1,11 @@
// Source adopted from // Source adopted from
// https://github.com/tildeio/helix-website/blob/master/crates/word_count/src/lib.rs // https://github.com/tildeio/helix-website/blob/master/crates/word_count/src/lib.rs
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
extern crate rayon; extern crate rayon;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::{pyclass, pymethods, pymodinit};
use rayon::prelude::*; use rayon::prelude::*;
use std::fs::File; use std::fs::File;
use std::io::prelude::*; use std::io::prelude::*;

4
examples/word-count/src/lib.rs
View File

@ -1,6 +1,6 @@
// Source adopted from // Source adopted from
// https://github.com/tildeio/helix-website/blob/master/crates/word_count/src/lib.rs // https://github.com/tildeio/helix-website/blob/master/crates/word_count/src/lib.rs
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
extern crate rayon; extern crate rayon;
@ -10,8 +10,6 @@ use std::io::prelude::*;
use pyo3::prelude::*; use pyo3::prelude::*;
use rayon::prelude::*; use rayon::prelude::*;
use pyo3::pymodinit;
fn matches(word: &str, search: &str) -> bool { fn matches(word: &str, search: &str) -> bool {
let mut search = search.chars(); let mut search = search.chars();
for ch in word.chars().skip_while(|ch| !ch.is_alphabetic()) { for ch in word.chars().skip_while(|ch| !ch.is_alphabetic()) {

50
guide/src/class.md
View File

@ -5,10 +5,10 @@
To define python custom class, rust struct needs to be annotated with `#[pyclass]` attribute. To define python custom class, rust struct needs to be annotated with `#[pyclass]` attribute.
```rust ```rust
# #![feature(proc_macro, specialization)] # #![feature(use_extern_macros, specialization)]
# extern crate pyo3; # extern crate pyo3;
# use pyo3::prelude::*; # use pyo3::prelude::*;
use pyo3::pyclass;
#[pyclass] #[pyclass]
struct MyClass { struct MyClass {
@ -45,11 +45,11 @@ To declare a constructor, you need to define a class method and annotate it with
attribute. Only the python `__new__` method can be specified, `__init__` is not available. attribute. Only the python `__new__` method can be specified, `__init__` is not available.
```rust ```rust
# #![feature(proc_macro, specialization)] # #![feature(use_extern_macros, specialization)]
# #
# extern crate pyo3; # extern crate pyo3;
# use pyo3::prelude::*; # use pyo3::prelude::*;
use pyo3::{pyclass, pymethods};
#[pyclass] #[pyclass]
struct MyClass { struct MyClass {
@ -92,10 +92,9 @@ By default `PyObject` is used as default base class. To override default base cl
with value of custom class struct. Subclass must call parent's `__new__` method. with value of custom class struct. Subclass must call parent's `__new__` method.
```rust ```rust
# #![feature(proc_macro, specialization)] # #![feature(use_extern_macros, specialization)]
# extern crate pyo3; # extern crate pyo3;
# use pyo3::prelude::*; # use pyo3::prelude::*;
# use pyo3::{pyclass, pymethods};
# #
#[pyclass] #[pyclass]
struct BaseClass { struct BaseClass {
@ -146,10 +145,9 @@ Descriptor methods can be defined in
attributes. i.e. attributes. i.e.
```rust ```rust
# #![feature(proc_macro, specialization)] # #![feature(use_extern_macros, specialization)]
# extern crate pyo3; # extern crate pyo3;
# use pyo3::prelude::*; # use pyo3::prelude::*;
# use pyo3::{pyclass, pymethods};
# #[pyclass] # #[pyclass]
# struct MyClass { # struct MyClass {
# num: i32, # num: i32,
@ -174,10 +172,9 @@ Descriptor name becomes function name with prefix removed. This is useful in cas
rust's special keywords like `type`. rust's special keywords like `type`.
```rust ```rust
# #![feature(proc_macro, specialization)] # #![feature(use_extern_macros, specialization)]
# extern crate pyo3; # extern crate pyo3;
# use pyo3::prelude::*; # use pyo3::prelude::*;
# use pyo3::{pyclass, pymethods};
# #[pyclass] # #[pyclass]
# struct MyClass { # struct MyClass {
# num: i32, # num: i32,
@ -206,10 +203,9 @@ Also both `#[getter]` and `#[setter]` attributes accepts one parameter.
If parameter is specified, it is used and property name. i.e. If parameter is specified, it is used and property name. i.e.
```rust ```rust
# #![feature(proc_macro, specialization)] # #![feature(use_extern_macros, specialization)]
# extern crate pyo3; # extern crate pyo3;
# use pyo3::prelude::*; # use pyo3::prelude::*;
# use pyo3::{pyclass, pymethods};
# #[pyclass] # #[pyclass]
# struct MyClass { # struct MyClass {
# num: i32, # num: i32,
@ -237,10 +233,9 @@ In this case property `number` is defined. And it is available from python code
For simple cases you can also define getters and setters in your Rust struct field definition, for example: For simple cases you can also define getters and setters in your Rust struct field definition, for example:
```rust ```rust
# #![feature(proc_macro, specialization)] # #![feature(use_extern_macros, specialization)]
# extern crate pyo3; # extern crate pyo3;
# use pyo3::prelude::*; # use pyo3::prelude::*;
# use pyo3::{pyclass, pymethods};
#[pyclass] #[pyclass]
struct MyClass { struct MyClass {
#[prop(get, set)] #[prop(get, set)]
@ -258,10 +253,9 @@ wrappers for all functions in this block with some variations, like descriptors,
class method static methods, etc. class method static methods, etc.
```rust ```rust
# #![feature(proc_macro, specialization)] # #![feature(use_extern_macros, specialization)]
# extern crate pyo3; # extern crate pyo3;
# use pyo3::prelude::*; # use pyo3::prelude::*;
# use pyo3::{pyclass, pymethods};
# #[pyclass] # #[pyclass]
# struct MyClass { # struct MyClass {
# num: i32, # num: i32,
@ -289,10 +283,9 @@ The return type must be `PyResult<T>` for some `T` that implements `IntoPyObject
get injected by method wrapper. i.e get injected by method wrapper. i.e
```rust ```rust
# #![feature(proc_macro, specialization)] # #![feature(use_extern_macros, specialization)]
# extern crate pyo3; # extern crate pyo3;
# use pyo3::prelude::*; # use pyo3::prelude::*;
# use pyo3::{pyclass, pymethods};
# #[pyclass] # #[pyclass]
# struct MyClass { # struct MyClass {
# num: i32, # num: i32,
@ -316,10 +309,9 @@ To specify class method for custom class, method needs to be annotated
with`#[classmethod]` attribute. with`#[classmethod]` attribute.
```rust ```rust
# #![feature(proc_macro, specialization)] # #![feature(use_extern_macros, specialization)]
# extern crate pyo3; # extern crate pyo3;
# use pyo3::prelude::*; # use pyo3::prelude::*;
# use pyo3::{pyclass, pymethods};
# #[pyclass] # #[pyclass]
# struct MyClass { # struct MyClass {
# num: i32, # num: i32,
@ -351,10 +343,9 @@ with `#[staticmethod]` attribute. The return type must be `PyResult<T>`
for some `T` that implements `IntoPyObject`. for some `T` that implements `IntoPyObject`.
```rust ```rust
# #![feature(proc_macro, specialization)] # #![feature(use_extern_macros, specialization)]
# extern crate pyo3; # extern crate pyo3;
# use pyo3::prelude::*; # use pyo3::prelude::*;
# use pyo3::{pyclass, pymethods};
# #[pyclass] # #[pyclass]
# struct MyClass { # struct MyClass {
# num: i32, # num: i32,
@ -377,10 +368,9 @@ To specify custom `__call__` method for custom class, call method needs to be an
with `#[call]` attribute. Arguments of the method are specified same as for instance method. with `#[call]` attribute. Arguments of the method are specified same as for instance method.
```rust ```rust
# #![feature(proc_macro, specialization)] # #![feature(use_extern_macros, specialization)]
# extern crate pyo3; # extern crate pyo3;
# use pyo3::prelude::*; # use pyo3::prelude::*;
# use pyo3::{pyclass, pymethods};
# #[pyclass] # #[pyclass]
# struct MyClass { # struct MyClass {
# num: i32, # num: i32,
@ -423,10 +413,10 @@ Each parameter could one of following type:
Example: Example:
```rust ```rust
# #![feature(proc_macro, specialization)] # #![feature(use_extern_macros, specialization)]
# extern crate pyo3; # extern crate pyo3;
# use pyo3::prelude::*; # use pyo3::prelude::*;
# use pyo3::{pyclass, pymethods}; #
# #[pyclass] # #[pyclass]
# struct MyClass { # struct MyClass {
# num: i32, # num: i32,
@ -527,11 +517,11 @@ These correspond to the slots `tp_traverse` and `tp_clear` in the Python C API.
as every cycle must contain at least one mutable reference. as every cycle must contain at least one mutable reference.
Example: Example:
```rust ```rust
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::{pyclass, pyproto};
#[pyclass] #[pyclass]
struct ClassWithGCSupport { struct ClassWithGCSupport {
@ -576,11 +566,11 @@ It includes two methods `__iter__` and `__next__`:
Example: Example:
```rust ```rust
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::{pyclass, pyproto};
#[pyclass] #[pyclass]
struct MyIterator { struct MyIterator {

2
guide/src/exception.md
View File

@ -131,7 +131,7 @@ trait can be implemented. In that case actual exception arguments creation get d
until `Python` object is available. until `Python` object is available.
```rust,ignore ```rust,ignore
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
use std::net::TcpListener; use std::net::TcpListener;

6
guide/src/function.md
View File

@ -10,7 +10,7 @@ One way is defining the function in the module definition.
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::pymodinit;
#[pymodinit] #[pymodinit]
fn rust2py(py: Python, m: &PyModule) -> PyResult<()> { fn rust2py(py: Python, m: &PyModule) -> PyResult<()> {
@ -34,13 +34,13 @@ as first parameter, the function name as second and an instance of `Python`
as third. as third.
```rust ```rust
#![feature(proc_macro, concat_idents)] #![feature(use_extern_macros, concat_idents)]
#[macro_use] #[macro_use]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::{pyfunction, pymodinit};
#[pyfunction] #[pyfunction]
fn double(x: usize) -> usize { fn double(x: usize) -> usize {

2
guide/src/module.md
View File

@ -8,7 +8,7 @@ As shown in the Getting Started chapter, you can create a module as follows:
extern crate pyo3; extern crate pyo3;
use pyo3::{PyResult, Python, PyModule}; use pyo3::{PyResult, Python, PyModule};
use pyo3::pymodinit;
// add bindings to the generated python module // add bindings to the generated python module
// N.B: names: "librust2py" must be the name of the `.so` or `.pyd` file // N.B: names: "librust2py" must be the name of the `.so` or `.pyd` file

4
guide/src/overview.md
View File

@ -59,12 +59,12 @@ features = ["extension-module"]
**`src/lib.rs`** **`src/lib.rs`**
```rust ```rust
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::pymodinit;
// Add bindings to the generated python module // Add bindings to the generated python module
// N.B: names: "librust2py" must be the name of the `.so` or `.pyd` file // N.B: names: "librust2py" must be the name of the `.so` or `.pyd` file

4
guide/src/rust-cpython.md
View File

@ -25,12 +25,12 @@ py_class!(class MyClass |py| {
**pyo3** **pyo3**
```rust ```rust
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::{pyclass, pymethods};
#[pyclass] #[pyclass]
struct MyClass { struct MyClass {

1
pyo3-derive-backend/src/module.rs
View File

@ -17,7 +17,6 @@ pub fn py3_init(fnname: &syn::Ident, name: &syn::Ident, doc: syn::Lit) -> TokenS
quote! { quote! {
#[no_mangle] #[no_mangle]
#[allow(non_snake_case)] #[allow(non_snake_case)]
#[doc(hidden)]
/// This autogenerated function is called by the python interpreter when importing /// This autogenerated function is called by the python interpreter when importing
/// the module. /// the module.
pub unsafe extern "C" fn #cb_name() -> *mut ::pyo3::ffi::PyObject { pub unsafe extern "C" fn #cb_name() -> *mut ::pyo3::ffi::PyObject {

3
pyo3cls/src/lib.rs
View File

@ -1,9 +1,8 @@
// Copyright (c) 2017-present PyO3 Project and Contributors // Copyright (c) 2017-present PyO3 Project and Contributors
//! This crate declares only the proc macro attributes, as a crate defining proc macro attributes //! This crate declares only the proc macro attributes, as a crate defining proc macro attributes
//! must not contain any other public items //! must not contain any other public items.
#![recursion_limit = "1024"] #![recursion_limit = "1024"]
#![feature(proc_macro)]
extern crate proc_macro; extern crate proc_macro;
extern crate proc_macro2; extern crate proc_macro2;

21
src/lib.rs
View File

@ -1,4 +1,4 @@
#![feature(specialization, proc_macro)] #![feature(specialization, use_extern_macros)]
//! Rust bindings to the Python interpreter. //! Rust bindings to the Python interpreter.
//! //!
@ -29,7 +29,7 @@
//! # Example //! # Example
//! //!
//! ```rust //! ```rust
//! #![feature(proc_macro, specialization)] //! #![feature(use_extern_macros, specialization)]
//! //!
//! extern crate pyo3; //! extern crate pyo3;
//! //!
@ -68,13 +68,11 @@
//! # Example //! # Example
//! //!
//! ```rust //! ```rust
//! #![feature(proc_macro, specialization)] //! #![feature(use_extern_macros, specialization)]
//! //!
//! extern crate pyo3; //! extern crate pyo3;
//! use pyo3::prelude::*; //! use pyo3::prelude::*;
//! //!
//! use pyo3::pymodinit;
//!
//! // Add bindings to the generated python module //! // Add bindings to the generated python module
//! // N.B: names: "librust2py" must be the name of the `.so` or `.pyd` file //! // N.B: names: "librust2py" must be the name of the `.so` or `.pyd` file
//! /// This module is implemented in Rust. //! /// This module is implemented in Rust.
@ -157,13 +155,16 @@ pub use conversion::{FromPyObject, PyTryFrom, PyTryInto,
pub mod class; pub mod class;
pub use class::*; pub use class::*;
pub use pyo3cls::{pyproto, pyclass, pymethods, pyfunction}; /// The proc macro attributes
pub mod proc_macro {
pub use pyo3cls::{pyproto, pyclass, pymethods, pyfunction};
#[cfg(Py_3)] #[cfg(Py_3)]
pub use pyo3cls::mod3init as pymodinit; pub use pyo3cls::mod3init as pymodinit;
#[cfg(not(Py_3))] #[cfg(not(Py_3))]
pub use pyo3cls::mod2init as pymodinit; pub use pyo3cls::mod2init as pymodinit;
}
/// Constructs a `&'static CStr` literal. /// Constructs a `&'static CStr` literal.
macro_rules! cstr { macro_rules! cstr {

10
src/prelude.rs
View File

@ -1,6 +1,6 @@
// Copyright (c) 2017-present PyO3 Project and Contributors // Copyright (c) 2017-present PyO3 Project and Contributors
//! The `PyO3` Prelude //! A collection of items you most likely want to have in scope when working with pyo3
//! //!
//! The purpose of this module is to alleviate imports of many common pyo3 traits //! The purpose of this module is to alleviate imports of many common pyo3 traits
//! by adding a glob import to the top of pyo3 heavy modules: //! by adding a glob import to the top of pyo3 heavy modules:
@ -22,3 +22,11 @@ pub use typeob::PyRawObject;
pub use instance::{PyToken, PyObjectWithToken, AsPyRef, Py, PyNativeType}; pub use instance::{PyToken, PyObjectWithToken, AsPyRef, Py, PyNativeType};
pub use conversion::{FromPyObject, PyTryFrom, PyTryInto, pub use conversion::{FromPyObject, PyTryFrom, PyTryInto,
ToPyObject, ToBorrowedObject, IntoPyObject, IntoPyTuple}; ToPyObject, ToBorrowedObject, IntoPyObject, IntoPyTuple};
pub use pyo3cls::{pyproto, pyclass, pymethods, pyfunction};
#[cfg(Py_3)]
pub use pyo3cls::mod3init as pymodinit;
#[cfg(not(Py_3))]
pub use pyo3cls::mod2init as pymodinit;

2
src/typeob.rs
View File

@ -103,7 +103,7 @@ impl<'a, T: ?Sized> PyTypeInfo for &'a T where T: PyTypeInfo {
/// ///
/// Example of custom class implementation with `__new__` method: /// Example of custom class implementation with `__new__` method:
/// ```rust,ignore /// ```rust,ignore
/// use pyo3::{pyclass, pymethods}; /// use pyo3::prelude::*;
/// ///
/// #[pyclass] /// #[pyclass]
/// struct MyClass { /// struct MyClass {

3
tests/test_arithmetics.rs
View File

@ -1,9 +1,8 @@
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::{pyclass, pyproto};
#[macro_use] #[macro_use]
mod common; mod common;

5
tests/test_buffer_protocol.rs
View File

@ -1,4 +1,4 @@
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
@ -8,9 +8,6 @@ use std::ptr;
use pyo3::ffi; use pyo3::ffi;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::pyclass;
use pyo3::pyproto;
#[pyclass] #[pyclass]
struct TestClass { struct TestClass {
vec: Vec<u8>, vec: Vec<u8>,

4
tests/test_class_basics.rs
View File

@ -1,11 +1,9 @@
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::pyclass;
#[macro_use] #[macro_use]
mod common; mod common;

5
tests/test_class_new.rs
View File

@ -1,12 +1,9 @@
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::pyclass;
use pyo3::pymethods;
#[pyclass] #[pyclass]
struct EmptyClassWithNew { struct EmptyClassWithNew {
token: PyToken, token: PyToken,

6
tests/test_dunder.rs
View File

@ -1,4 +1,4 @@
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
@ -6,10 +6,6 @@ use pyo3::ffi;
use pyo3::prelude::*; use pyo3::prelude::*;
use std::{isize, iter}; use std::{isize, iter};
use pyo3::pyclass;
use pyo3::pymethods;
use pyo3::pyproto;
#[macro_use] #[macro_use]
mod common; mod common;

6
tests/test_gc.rs
View File

@ -1,4 +1,4 @@
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
@ -8,10 +8,6 @@ use std::cell::RefCell;
use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc; use std::sync::Arc;
use pyo3::pyclass;
use pyo3::pymethods;
use pyo3::pyproto;
#[macro_use] #[macro_use]
mod common; mod common;

5
tests/test_getter_setter.rs
View File

@ -1,13 +1,10 @@
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use std::isize; use std::isize;
use pyo3::pyclass;
use pyo3::pymethods;
#[macro_use] #[macro_use]
mod common; mod common;

4
tests/test_inheritance.rs
View File

@ -1,12 +1,10 @@
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use std::isize; use std::isize;
use pyo3::{pyclass, pymethods};
#[macro_use] #[macro_use]
mod common; mod common;

5
tests/test_methods.rs
View File

@ -1,12 +1,9 @@
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::pyclass;
use pyo3::pymethods;
#[macro_use] #[macro_use]
mod common; mod common;

9
tests/test_module.rs
View File

@ -1,10 +1,9 @@
#![feature(proc_macro, specialization, concat_idents)] #![feature(use_extern_macros, specialization, concat_idents)]
#[macro_use] #[macro_use]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use pyo3::{pyclass, pyfunction, pymodinit};
#[pyclass] #[pyclass]
struct EmptyClass {} struct EmptyClass {}
@ -80,7 +79,11 @@ fn test_module_renaming() {
PyObject::from_owned_ptr(py, PyInit_other_name()) PyObject::from_owned_ptr(py, PyInit_other_name())
}).unwrap(); }).unwrap();
py.run("assert different_name.__name__ == 'other_name'", None, Some(d)).unwrap(); py.run(
"assert different_name.__name__ == 'other_name'",
None,
Some(d),
).unwrap();
} }
#[test] #[test]

5
tests/test_various.rs
View File

@ -1,13 +1,10 @@
#![feature(proc_macro, specialization)] #![feature(use_extern_macros, specialization)]
extern crate pyo3; extern crate pyo3;
use pyo3::prelude::*; use pyo3::prelude::*;
use std::isize; use std::isize;
use pyo3::pyclass;
use pyo3::pymethods;
#[macro_use] #[macro_use]
mod common; mod common;