Switch to pyO3 0.16

Cargo.toml

@@ -15,7 +15,7 @@ exclude = ["/.github/*", "*.ipynb", "./docs/*"]
 
 [dependencies]
 num-traits = "0.2"
-pyo3 = { version = "0.15", optional = true }
+pyo3 = { version = "0.16", optional = true }
 
 [features]
 default = []

build_wheel/Cargo.toml

@@ -19,4 +19,4 @@ crate-type = ["cdylib"]
 
 [dependencies]
 num-dual = { path = "..", features = ["python"]}
-pyo3 = { version = "0.15", features = ["extension-module", "abi3", "abi3-py36", "multiple-pymethods"] }
+pyo3 = { version = "0.16", features = ["extension-module", "abi3", "abi3-py37", "multiple-pymethods"] }

src/python/dual.rs

@@ -1,6 +1,5 @@
 use crate::*;
 use pyo3::exceptions::PyTypeError;
-use pyo3::number::PyNumberProtocol;
 use pyo3::prelude::*;
 
 #[pyclass(name = "Dual64")]

src/python/dual2.rs

@@ -1,7 +1,6 @@
 use super::dual::PyDual64;
 use crate::*;
 use pyo3::exceptions::PyTypeError;
-use pyo3::number::PyNumberProtocol;
 use pyo3::prelude::*;
 
 #[pyclass(name = "Dual2_64")]

src/python/dual3.rs

@@ -1,7 +1,6 @@
 use super::dual::PyDual64;
 use crate::*;
 use pyo3::exceptions::PyTypeError;
-use pyo3::number::PyNumberProtocol;
 use pyo3::prelude::*;
 
 #[pyclass(name = "Dual3_64")]
@@ -72,7 +71,7 @@ impl_dual_num!(PyDual3Dual64, Dual3<Dual64, f64>, PyDual64);
 
 #[pyfunction]
 #[pyo3(text_signature = "(x)")]
-fn derive3(x: &PyAny) -> PyResult<PyObject> {
+pub fn derive3(x: &PyAny) -> PyResult<PyObject> {
     Python::with_gil(|py| {
         if let Ok(x) = x.extract::<f64>() {
             return Ok(

src/python/hyperdual.rs

@@ -2,7 +2,6 @@ use super::dual::PyDual64;
 use super::dual2::{PyDual2Dual64, PyDual2_64};
 use crate::*;
 use pyo3::exceptions::PyTypeError;
-use pyo3::number::PyNumberProtocol;
 use pyo3::prelude::*;
 
 #[pyclass(name = "HyperDual64")]

src/python/macros.rs

@@ -214,14 +214,14 @@ macro_rules! impl_dual_num {
             }
         }
 
-        #[pyproto]
-        impl PyNumberProtocol for $py_type_name {
-            fn __add__(lhs: PyRef<'p, Self>, rhs: &PyAny) -> PyResult<Self> {
+        #[pymethods]
+        impl $py_type_name {
+            fn __add__(&self, rhs: &PyAny) -> PyResult<Self> {
                 if let Ok(r) = rhs.extract::<f64>() {
-                    return Ok((lhs.0 + r).into());
+                    return Ok((self.0 + r).into());
                 };
                 if let Ok(r) = rhs.extract::<Self>() {
-                    return Ok((lhs.0 + r.0).into());
+                    return Ok((self.0 + r.0).into());
                 };
                 Err(PyErr::new::<PyTypeError, _>(format!("not implemented!")))
             }
@@ -233,12 +233,12 @@ macro_rules! impl_dual_num {
                 Err(PyErr::new::<PyTypeError, _>(format!("not implemented!")))
             }
 
-            fn __sub__(lhs: PyRef<'p, Self>, rhs: &PyAny) -> PyResult<Self> {
+            fn __sub__(&self, rhs: &PyAny) -> PyResult<Self> {
                 if let Ok(r) = rhs.extract::<f64>() {
-                    return Ok((lhs.0 - r).into());
+                    return Ok((self.0 - r).into());
                 };
                 if let Ok(r) = rhs.extract::<Self>() {
-                    return Ok((lhs.0 - r.0).into());
+                    return Ok((self.0 - r.0).into());
                 };
                 Err(PyErr::new::<PyTypeError, _>(format!("not implemented!")))
             }
@@ -250,12 +250,12 @@ macro_rules! impl_dual_num {
                 Err(PyErr::new::<PyTypeError, _>(format!("not implemented!")))
             }
 
-            fn __mul__(lhs: PyRef<'p, Self>, rhs: &PyAny) -> PyResult<Self> {
+            fn __mul__(&self, rhs: &PyAny) -> PyResult<Self> {
                 if let Ok(r) = rhs.extract::<f64>() {
-                    return Ok((lhs.0 * r).into());
+                    return Ok((self.0 * r).into());
                 };
                 if let Ok(r) = rhs.extract::<Self>() {
-                    return Ok((lhs.0 * r.0).into());
+                    return Ok((self.0 * r.0).into());
                 };
                 Err(PyErr::new::<PyTypeError, _>(format!("not implemented!")))
             }
@@ -267,12 +267,12 @@ macro_rules! impl_dual_num {
                 Err(PyErr::new::<PyTypeError, _>(format!("not implemented!")))
             }
 
-            fn __truediv__(lhs: PyRef<'p, Self>, rhs: &PyAny) -> PyResult<Self> {
+            fn __truediv__(&self, rhs: &PyAny) -> PyResult<Self> {
                 if let Ok(r) = rhs.extract::<f64>() {
-                    return Ok((lhs.0 / r).into());
+                    return Ok((self.0 / r).into());
                 };
                 if let Ok(r) = rhs.extract::<Self>() {
-                    return Ok((lhs.0 / r.0).into());
+                    return Ok((self.0 / r.0).into());
                 };
                 Err(PyErr::new::<PyTypeError, _>(format!("not implemented!")))
             }
@@ -284,15 +284,15 @@ macro_rules! impl_dual_num {
                 Err(PyErr::new::<PyTypeError, _>(format!("not implemented!")))
             }
 
-            fn __pow__(lhs: &PyAny, rhs: &PyAny, _mod: Option<u32>) -> PyResult<Self> {
-                if let (Ok(l), Ok(r)) = (lhs.extract::<Self>(), rhs.extract::<i32>()) {
-                    return Ok(l.0.powi(r).into());
+            fn __pow__(&self, rhs: &PyAny, _mod: Option<u32>) -> PyResult<Self> {
+                if let Ok(r) = rhs.extract::<i32>() {
+                    return Ok(self.0.powi(r).into());
                 };
-                if let (Ok(l), Ok(r)) = (lhs.extract::<Self>(), rhs.extract::<f64>()) {
-                    return Ok(l.0.powf(r).into());
+                if let Ok(r) = rhs.extract::<f64>() {
+                    return Ok(self.0.powf(r).into());
                 };
-                if let (Ok(l), Ok(r)) = (lhs.extract::<Self>(), rhs.extract::<Self>()) {
-                    return Ok(l.0.powd(r.0).into());
+                if let Ok(r) = rhs.extract::<Self>() {
+                    return Ok(self.0.powd(r.0).into());
                 };
                 Err(PyErr::new::<PyTypeError, _>(format!("not implemented!")))
             }
@@ -302,8 +302,8 @@ macro_rules! impl_dual_num {
             }
         }
 
-        #[pyproto]
-        impl pyo3::class::basic::PyObjectProtocol for $py_type_name {
+        #[pymethods]
+        impl $py_type_name {
             fn __repr__(&self) -> PyResult<String> {
                 Ok(self.0.to_string())
             }

src/python/mod.rs

@@ -8,9 +8,9 @@ mod dual2;
 mod dual3;
 mod hyperdual;
 
-use dual::__pyo3_get_function_derive1;
-use dual3::__pyo3_get_function_derive3;
-use hyperdual::__pyo3_get_function_derive2;
+use dual::derive1;
+use dual3::derive3;
+use hyperdual::derive2;
 
 pub use dual::PyDual64;
 pub use dual2::{PyDual2Dual64, PyDual2_64};