Format

Author: termoshtt

src/array.rs

@@ -1,15 +1,15 @@
 //! Untyped safe interface for NumPy ndarray
 
-use npyffi;
-use pyffi;
 use cpython::*;
 use ndarray::*;
+use npyffi;
+use pyffi;
 
 use std::os::raw::c_void;
 use std::ptr::null_mut;
 
-use super::*;
 use super::error::ArrayCastError;
+use super::*;
 
 /// Untyped safe interface for NumPy ndarray.
 pub struct PyArray(PyObject);
@@ -85,8 +85,10 @@ impl PyArray {
     fn ndarray_shape<A>(&self) -> StrideShape<IxDyn> {
         // FIXME may be done more simply
         let shape: Shape<_> = Dim(self.shape()).into();
-        let st: Vec<usize> =
-            self.strides().iter().map(|&x| x as usize / ::std::mem::size_of::<A>()).collect();
+        let st: Vec<usize> = self.strides()
+            .iter()
+            .map(|&x| x as usize / ::std::mem::size_of::<A>())
+            .collect();
         shape.strides(Dim(st))
     }
 
@@ -110,13 +112,23 @@ impl PyArray {
     /// Get data as a ndarray::ArrayView
     pub fn as_array<A: types::TypeNum>(&self) -> Result<ArrayViewD<A>, ArrayCastError> {
         self.type_check::<A>()?;
-        unsafe { Ok(ArrayView::from_shape_ptr(self.ndarray_shape::<A>(), self.data())) }
+        unsafe {
+            Ok(ArrayView::from_shape_ptr(
+                self.ndarray_shape::<A>(),
+                self.data(),
+            ))
+        }
     }
 
     /// Get data as a ndarray::ArrayViewMut
     pub fn as_array_mut<A: types::TypeNum>(&self) -> Result<ArrayViewMutD<A>, ArrayCastError> {
         self.type_check::<A>()?;
-        unsafe { Ok(ArrayViewMut::from_shape_ptr(self.ndarray_shape::<A>(), self.data())) }
+        unsafe {
+            Ok(ArrayViewMut::from_shape_ptr(
+                self.ndarray_shape::<A>(),
+                self.data(),
+            ))
+        }
     }
 
     /// Get data as a Rust immutable slice
@@ -131,23 +143,25 @@ impl PyArray {
         unsafe { Ok(::std::slice::from_raw_parts_mut(self.data(), self.len())) }
     }
 
-    pub unsafe fn new_<T: TypeNum>(py: Python,
-                                   np: &PyArrayModule,
-                                   dims: &[usize],
-                                   strides: *mut npy_intp,
-                                   data: *mut c_void)
-                                   -> Self {
+    pub unsafe fn new_<T: TypeNum>(
+        py: Python,
+        np: &PyArrayModule,
+        dims: &[usize],
+        strides: *mut npy_intp,
+        data: *mut c_void,
+    ) -> Self {
         let dims: Vec<_> = dims.iter().map(|d| *d as npy_intp).collect();
-        let ptr = np.PyArray_New(np.get_type_object(npyffi::ArrayType::PyArray_Type),
-                                     dims.len() as i32,
-                                     dims.as_ptr() as *mut npy_intp,
-                                     T::typenum(),
-                                     strides,
-                                     data,
-                                     0,                      // itemsize
-                                     0,                      // flag
-                                     ::std::ptr::null_mut()  //obj
-                                     );
+        let ptr = np.PyArray_New(
+            np.get_type_object(npyffi::ArrayType::PyArray_Type),
+            dims.len() as i32,
+            dims.as_ptr() as *mut npy_intp,
+            T::typenum(),
+            strides,
+            data,
+            0,                      // itemsize
+            0,                      // flag
+            ::std::ptr::null_mut(), //obj
+        );
         Self::from_owned_ptr(py, ptr)
     }
 
@@ -157,29 +171,33 @@ impl PyArray {
     }
 
     /// a wrapper of [PyArray_ZEROS](https://docs.scipy.org/doc/numpy/reference/c-api.array.html#c.PyArray_ZEROS)
-    pub fn zeros<T: TypeNum>(py: Python,
-                             np: &PyArrayModule,
-                             dims: &[usize],
-                             order: NPY_ORDER)
-                             -> Self {
+    pub fn zeros<T: TypeNum>(
+        py: Python,
+        np: &PyArrayModule,
+        dims: &[usize],
+        order: NPY_ORDER,
+    ) -> Self {
         let dims: Vec<npy_intp> = dims.iter().map(|d| *d as npy_intp).collect();
         unsafe {
             let descr = np.PyArray_DescrFromType(T::typenum());
-            let ptr = np.PyArray_Zeros(dims.len() as i32,
-                                       dims.as_ptr() as *mut npy_intp,
-                                       descr,
-                                       order as i32);
+            let ptr = np.PyArray_Zeros(
+                dims.len() as i32,
+                dims.as_ptr() as *mut npy_intp,
+                descr,
+                order as i32,
+            );
             Self::from_owned_ptr(py, ptr)
         }
     }
 
     /// a wrapper of [PyArray_Arange](https://docs.scipy.org/doc/numpy/reference/c-api.array.html#c.PyArray_Arange)
-    pub fn arange<T: TypeNum>(py: Python,
-                              np: &PyArrayModule,
-                              start: f64,
-                              stop: f64,
-                              step: f64)
-                              -> Self {
+    pub fn arange<T: TypeNum>(
+        py: Python,
+        np: &PyArrayModule,
+        start: f64,
+        stop: f64,
+        step: f64,
+    ) -> Self {
         unsafe {
             let ptr = np.PyArray_Arange(start, stop, step, T::typenum());
             Self::from_owned_ptr(py, ptr)
@@ -230,9 +248,10 @@ impl PythonObject for PyArray {
 }
 
 impl PythonObjectWithCheckedDowncast for PyArray {
-    fn downcast_from<'p>(py: Python<'p>,
-                         obj: PyObject)
-                         -> Result<PyArray, PythonObjectDowncastError<'p>> {
+    fn downcast_from<'p>(
+        py: Python<'p>,
+        obj: PyObject,
+    ) -> Result<PyArray, PythonObjectDowncastError<'p>> {
         let np = PyArrayModule::import(py).unwrap();
         unsafe {
             if npyffi::PyArray_Check(&np, obj.as_ptr()) != 0 {
@@ -243,9 +262,10 @@ impl PythonObjectWithCheckedDowncast for PyArray {
         }
     }
 
-    fn downcast_borrow_from<'a, 'p>(py: Python<'p>,
-                                    obj: &'a PyObject)
-                                    -> Result<&'a PyArray, PythonObjectDowncastError<'p>> {
+    fn downcast_borrow_from<'a, 'p>(
+        py: Python<'p>,
+        obj: &'a PyObject,
+    ) -> Result<&'a PyArray, PythonObjectDowncastError<'p>> {
         let np = PyArrayModule::import(py).unwrap();
         unsafe {
             if npyffi::PyArray_Check(&np, obj.as_ptr()) != 0 {

src/convert.rs

@@ -1,11 +1,10 @@
-
 use cpython::Python;
 use ndarray::*;
 
-use std::os::raw::c_void;
-use std::ptr::null_mut;
 use std::iter::Iterator;
 use std::mem::size_of;
+use std::os::raw::c_void;
+use std::ptr::null_mut;
 
 use super::*;
 
@@ -44,7 +43,8 @@ pub trait ToPyArray {
 }
 
 impl<Iter, T: TypeNum> ToPyArray for Iter
-    where Iter: Iterator<Item = T> + Sized
+where
+    Iter: Iterator<Item = T> + Sized,
 {
     fn to_pyarray(self, py: Python, np: &PyArrayModule) -> PyArray {
         let vec: Vec<T> = self.collect();

src/error.rs

@@ -1,8 +1,8 @@
 //! Define Errors
 
+use cpython::*;
 use std::error;
 use std::fmt;
-use cpython::*;
 
 pub trait IntoPyErr {
     fn into_pyerr(self, py: Python, msg: &str) -> PyErr;

src/lib.rs

@@ -1,18 +1,17 @@
-
-extern crate python3_sys as pyffi;
 extern crate cpython;
 extern crate libc;
-extern crate num_complex;
 extern crate ndarray;
+extern crate num_complex;
+extern crate python3_sys as pyffi;
 
-pub mod types;
 pub mod array;
-pub mod npyffi;
-pub mod error;
 pub mod convert;
+pub mod error;
+pub mod npyffi;
+pub mod types;
 
 pub use array::PyArray;
-pub use types::*;
-pub use error::*;
 pub use convert::{IntoPyArray, ToPyArray};
+pub use error::*;
 pub use npyffi::{PyArrayModule, PyUFuncModule};
+pub use types::*;

src/npyffi/array.rs

@@ -2,14 +2,14 @@
 //!
 //! https://docs.scipy.org/doc/numpy/reference/c-api.array.html
 
-use std::os::raw::*;
-use std::ptr::null_mut;
 use libc::FILE;
 use std::ops::Deref;
+use std::os::raw::*;
+use std::ptr::null_mut;
 
+use cpython::{ObjectProtocol, PyModule, PyResult, Python, PythonObject};
 use pyffi;
 use pyffi::{PyObject, PyTypeObject};
-use cpython::{Python, PythonObject, ObjectProtocol, PyResult, PyModule};
 
 use npyffi::*;
 
@@ -48,8 +48,8 @@ impl PyArrayModule {
         let numpy = py.import("numpy.core.multiarray")?;
         let c_api = numpy.as_object().getattr(py, "_ARRAY_API")?;
         let api = unsafe {
-            pyffi::PyCapsule_GetPointer(c_api.as_object().as_ptr(), null_mut()) as
-            *const *const c_void
+            pyffi::PyCapsule_GetPointer(c_api.as_object().as_ptr(), null_mut())
+                as *const *const c_void
         };
         Ok(Self {
             numpy: numpy,
@@ -331,45 +331,47 @@ impl PyArrayModule {
 }
 }} // impl_array_type!;
 
-impl_array_type!((1, PyBigArray_Type),
-                 (2, PyArray_Type),
-                 (3, PyArrayDescr_Type),
-                 (4, PyArrayFlags_Type),
-                 (5, PyArrayIter_Type),
-                 (6, PyArrayMultiIter_Type),
-                 (7, NPY_NUMUSERTYPES),
-                 (8, PyBoolArrType_Type),
-                 (9, _PyArrayScalar_BoolValues),
-                 (10, PyGenericArrType_Type),
-                 (11, PyNumberArrType_Type),
-                 (12, PyIntegerArrType_Type),
-                 (13, PySignedIntegerArrType_Type),
-                 (14, PyUnsignedIntegerArrType_Type),
-                 (15, PyInexactArrType_Type),
-                 (16, PyFloatingArrType_Type),
-                 (17, PyComplexFloatingArrType_Type),
-                 (18, PyFlexibleArrType_Type),
-                 (19, PyCharacterArrType_Type),
-                 (20, PyByteArrType_Type),
-                 (21, PyShortArrType_Type),
-                 (22, PyIntArrType_Type),
-                 (23, PyLongArrType_Type),
-                 (24, PyLongLongArrType_Type),
-                 (25, PyUByteArrType_Type),
-                 (26, PyUShortArrType_Type),
-                 (27, PyUIntArrType_Type),
-                 (28, PyULongArrType_Type),
-                 (29, PyULongLongArrType_Type),
-                 (30, PyFloatArrType_Type),
-                 (31, PyDoubleArrType_Type),
-                 (32, PyLongDoubleArrType_Type),
-                 (33, PyCFloatArrType_Type),
-                 (34, PyCDoubleArrType_Type),
-                 (35, PyCLongDoubleArrType_Type),
-                 (36, PyObjectArrType_Type),
-                 (37, PyStringArrType_Type),
-                 (38, PyUnicodeArrType_Type),
-                 (39, PyVoidArrType_Type));
+impl_array_type!(
+    (1, PyBigArray_Type),
+    (2, PyArray_Type),
+    (3, PyArrayDescr_Type),
+    (4, PyArrayFlags_Type),
+    (5, PyArrayIter_Type),
+    (6, PyArrayMultiIter_Type),
+    (7, NPY_NUMUSERTYPES),
+    (8, PyBoolArrType_Type),
+    (9, _PyArrayScalar_BoolValues),
+    (10, PyGenericArrType_Type),
+    (11, PyNumberArrType_Type),
+    (12, PyIntegerArrType_Type),
+    (13, PySignedIntegerArrType_Type),
+    (14, PyUnsignedIntegerArrType_Type),
+    (15, PyInexactArrType_Type),
+    (16, PyFloatingArrType_Type),
+    (17, PyComplexFloatingArrType_Type),
+    (18, PyFlexibleArrType_Type),
+    (19, PyCharacterArrType_Type),
+    (20, PyByteArrType_Type),
+    (21, PyShortArrType_Type),
+    (22, PyIntArrType_Type),
+    (23, PyLongArrType_Type),
+    (24, PyLongLongArrType_Type),
+    (25, PyUByteArrType_Type),
+    (26, PyUShortArrType_Type),
+    (27, PyUIntArrType_Type),
+    (28, PyULongArrType_Type),
+    (29, PyULongLongArrType_Type),
+    (30, PyFloatArrType_Type),
+    (31, PyDoubleArrType_Type),
+    (32, PyLongDoubleArrType_Type),
+    (33, PyCFloatArrType_Type),
+    (34, PyCDoubleArrType_Type),
+    (35, PyCLongDoubleArrType_Type),
+    (36, PyObjectArrType_Type),
+    (37, PyStringArrType_Type),
+    (38, PyUnicodeArrType_Type),
+    (39, PyVoidArrType_Type)
+);
 
 #[allow(non_snake_case)]
 pub unsafe fn PyArray_Check(np: &PyArrayModule, op: *mut PyObject) -> c_int {

src/npyffi/mod.rs

@@ -9,12 +9,12 @@
 //! - http://docs.python.jp/3/c-api/
 //! - http://dgrunwald.github.io/rust-cpython/doc/cpython/
 
-pub mod types;
-pub mod objects;
 pub mod array;
+pub mod objects;
+pub mod types;
 pub mod ufunc;
 
-pub use self::types::*;
-pub use self::objects::*;
 pub use self::array::*;
+pub use self::objects::*;
+pub use self::types::*;
 pub use self::ufunc::*;