Merge pull request #816 from kngwyu/expose-pyany

Expose PyAny to lib.rs and prelude

CHANGELOG.md

@@ -18,6 +18,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 * Bumped minimum Rust version to `1.42.0-nightly 2020-01-21`. [#761](https://github.com/PyO3/pyo3/pull/761)
 * `PyRef` and `PyRefMut` are renewed for `PyCell`. [#770](https://github.com/PyO3/pyo3/pull/770)
 * Some new FFI functions for Python 3.8. [#784](https://github.com/PyO3/pyo3/pull/784)
+* `PyAny` is now on the top level module and prelude. [#816](https://github.com/PyO3/pyo3/pull/816)
 
 ### Added
 * `PyCell`, which has RefCell-like features. [#770](https://github.com/PyO3/pyo3/pull/770)

guide/src/class.md

@@ -22,7 +22,6 @@ Specifically, the following implementation is generated:
 
 ```rust
 use pyo3::prelude::*;
-use pyo3::types::PyAny;
 
 /// Class for demonstration
 struct MyClass {
@@ -326,7 +325,7 @@ that inherit native types. Even in such cases, you can unsafely get a base class
 
 ```rust
 # use pyo3::prelude::*;
-use pyo3::types::{PyAny, PyDict};
+use pyo3::types::PyDict;
 use pyo3::{AsPyPointer, PyNativeType};
 use std::collections::HashMap;
 

guide/src/migration.md

@@ -129,7 +129,7 @@ let obj_ref_mut: &mut MyClass = obj.extract().unwrap();
 After:
 ```
 # use pyo3::prelude::*;
-# use pyo3::types::{PyAny, IntoPyDict};
+# use pyo3::types::IntoPyDict;
 # #[pyclass] #[derive(Clone)] struct MyClass {}
 # #[pymethods] impl MyClass { #[new]fn new() -> Self { MyClass {} }}
 # let gil = Python::acquire_gil();

pyo3-derive-backend/src/pyclass.rs

@@ -43,7 +43,7 @@ impl Default for PyClassArgs {
             // We need the 0 as value for the constant we're later building using quote for when there
             // are no other flags
             flags: vec![parse_quote! { 0 }],
-            base: parse_quote! { pyo3::types::PyAny },
+            base: parse_quote! { pyo3::PyAny },
             has_extends: false,
         }
     }
@@ -364,12 +364,12 @@ fn impl_class(
     let base_layout = if attr.has_extends {
         quote! { <Self::BaseType as pyo3::derive_utils::PyBaseTypeUtils>::LayoutAsBase }
     } else {
-        quote! { pyo3::pycell::PyCellBase<pyo3::types::PyAny> }
+        quote! { pyo3::pycell::PyCellBase<pyo3::PyAny> }
     };
     let base_nativetype = if attr.has_extends {
         quote! { <Self::BaseType as pyo3::derive_utils::PyBaseTypeUtils>::BaseNativeType }
     } else {
-        quote! { pyo3::types::PyAny }
+        quote! { pyo3::PyAny }
     };
 
     // If #cls is not extended type, we allow Self->PyObject conversion

src/buffer.rs

@@ -18,11 +18,7 @@
 
 //! `PyBuffer` implementation
 use crate::err::{self, PyResult};
-use crate::exceptions;
-use crate::ffi;
-use crate::types::PyAny;
-use crate::AsPyPointer;
-use crate::Python;
+use crate::{exceptions, ffi, AsPyPointer, PyAny, Python};
 use std::ffi::CStr;
 use std::os::raw;
 use std::pin::Pin;

src/class/basic.rs

@@ -10,10 +10,10 @@
 
 use crate::callback::{BoolCallbackConverter, HashConverter, PyObjectCallbackConverter};
 use crate::class::methods::PyMethodDef;
-use crate::err::{PyErr, PyResult};
-use crate::objectprotocol::ObjectProtocol;
-use crate::types::PyAny;
-use crate::{exceptions, ffi, FromPyObject, IntoPy, IntoPyPointer, PyClass, PyObject, Python};
+use crate::{
+    exceptions, ffi, FromPyObject, IntoPy, IntoPyPointer, ObjectProtocol, PyAny, PyClass, PyErr,
+    PyObject, PyResult, Python,
+};
 use std::os::raw::c_int;
 
 /// Operators for the __richcmp__ method
@@ -232,7 +232,7 @@ where
             }
 
             let slf = py.from_borrowed_ptr::<crate::PyCell<T>>(slf);
-            let arg = py.from_borrowed_ptr::<crate::types::PyAny>(arg);
+            let arg = py.from_borrowed_ptr::<crate::PyAny>(arg);
             call_ref_with_converter!(
                 slf,
                 PyObjectCallbackConverter::<T::Success>(std::marker::PhantomData),

src/class/macros.rs

@@ -90,7 +90,7 @@ macro_rules! py_binary_func {
             let py = $crate::Python::assume_gil_acquired();
             let _pool = $crate::GILPool::new(py);
             let slf = py.from_borrowed_ptr::<$crate::PyCell<T>>(slf);
-            let arg = py.from_borrowed_ptr::<$crate::types::PyAny>(arg);
+            let arg = py.from_borrowed_ptr::<$crate::PyAny>(arg);
             $call!(slf, $conv, py, $f, arg)
         }
         Some(wrap::<$class>)
@@ -111,8 +111,8 @@ macro_rules! py_binary_num_func {
             use $crate::ObjectProtocol;
             let py = $crate::Python::assume_gil_acquired();
             let _pool = $crate::GILPool::new(py);
-            let lhs = py.from_borrowed_ptr::<$crate::types::PyAny>(lhs);
-            let rhs = py.from_borrowed_ptr::<$crate::types::PyAny>(rhs);
+            let lhs = py.from_borrowed_ptr::<$crate::PyAny>(lhs);
+            let rhs = py.from_borrowed_ptr::<$crate::PyAny>(rhs);
 
             let result = match lhs.extract() {
                 Ok(lhs) => match rhs.extract() {
@@ -144,7 +144,7 @@ macro_rules! py_binary_self_func {
             let py = $crate::Python::assume_gil_acquired();
             let _pool = $crate::GILPool::new(py);
             let slf_ = py.from_borrowed_ptr::<$crate::PyCell<T>>(slf);
-            let arg = py.from_borrowed_ptr::<$crate::types::PyAny>(arg);
+            let arg = py.from_borrowed_ptr::<$crate::PyAny>(arg);
             let result = call_mut!(slf_, $f, arg);
             match result {
                 Ok(_) => {
@@ -207,8 +207,8 @@ macro_rules! py_ternary_func {
             let py = $crate::Python::assume_gil_acquired();
             let _pool = $crate::GILPool::new(py);
             let slf = py.from_borrowed_ptr::<$crate::PyCell<T>>(slf);
-            let arg1 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg1);
-            let arg2 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg2);
+            let arg1 = py.from_borrowed_ptr::<$crate::PyAny>(arg1);
+            let arg2 = py.from_borrowed_ptr::<$crate::PyAny>(arg2);
 
             call_ref_with_converter!(slf, $conv, py, $f, arg1, arg2)
         }
@@ -233,9 +233,9 @@ macro_rules! py_ternary_num_func {
 
             let py = $crate::Python::assume_gil_acquired();
             let _pool = $crate::GILPool::new(py);
-            let arg1 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg1);
-            let arg2 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg2);
-            let arg3 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg3);
+            let arg1 = py.from_borrowed_ptr::<$crate::PyAny>(arg1);
+            let arg2 = py.from_borrowed_ptr::<$crate::PyAny>(arg2);
+            let arg3 = py.from_borrowed_ptr::<$crate::PyAny>(arg3);
 
             let result = match arg1.extract() {
                 Ok(arg1) => match arg2.extract() {
@@ -271,8 +271,8 @@ macro_rules! py_ternary_self_func {
             let py = $crate::Python::assume_gil_acquired();
             let _pool = $crate::GILPool::new(py);
             let slf_cell = py.from_borrowed_ptr::<$crate::PyCell<T>>(slf);
-            let arg1 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg1);
-            let arg2 = py.from_borrowed_ptr::<$crate::types::PyAny>(arg2);
+            let arg1 = py.from_borrowed_ptr::<$crate::PyAny>(arg1);
+            let arg2 = py.from_borrowed_ptr::<$crate::PyAny>(arg2);
             let result = call_mut!(slf_cell, $f, arg1, arg2);
             match result {
                 Ok(_) => slf,
@@ -307,8 +307,8 @@ macro_rules! py_func_set {
                     ),
                 ))
             } else {
-                let name = py.from_borrowed_ptr::<$crate::types::PyAny>(name);
-                let value = py.from_borrowed_ptr::<$crate::types::PyAny>(value);
+                let name = py.from_borrowed_ptr::<$crate::PyAny>(name);
+                let value = py.from_borrowed_ptr::<$crate::PyAny>(value);
                 call_mut!(slf, $fn_set, name, value)
             };
             match result {
@@ -338,7 +338,7 @@ macro_rules! py_func_del {
 
             let result = if value.is_null() {
                 let slf = py.from_borrowed_ptr::<$crate::PyCell<U>>(slf);
-                let name = py.from_borrowed_ptr::<$crate::types::PyAny>(name);
+                let name = py.from_borrowed_ptr::<$crate::PyAny>(name);
 
                 call_mut!(slf, $fn_del, name)
             } else {
@@ -371,12 +371,12 @@ macro_rules! py_func_set_del {
             let py = $crate::Python::assume_gil_acquired();
             let _pool = $crate::GILPool::new(py);
             let slf = py.from_borrowed_ptr::<$crate::PyCell<$generic>>(slf);
-            let name = py.from_borrowed_ptr::<$crate::types::PyAny>(name);
+            let name = py.from_borrowed_ptr::<$crate::PyAny>(name);
 
             let result = if value.is_null() {
                 call_mut!(slf, $fn_del, name)
             } else {
-                let value = py.from_borrowed_ptr::<$crate::types::PyAny>(value);
+                let value = py.from_borrowed_ptr::<$crate::PyAny>(value);
                 call_mut!(slf, $fn_set, name, value)
             };
             match result {

src/class/sequence.rs

@@ -6,8 +6,7 @@
 use crate::callback::{BoolCallbackConverter, LenResultConverter, PyObjectCallbackConverter};
 use crate::err::{PyErr, PyResult};
 use crate::objectprotocol::ObjectProtocol;
-use crate::types::PyAny;
-use crate::{exceptions, ffi, FromPyObject, IntoPy, PyClass, PyObject, Python};
+use crate::{exceptions, ffi, FromPyObject, IntoPy, PyAny, PyClass, PyObject, Python};
 use std::os::raw::c_int;
 
 /// Sequence interface

src/conversion.rs

@@ -4,9 +4,8 @@
 use crate::err::{self, PyDowncastError, PyResult};
 use crate::object::PyObject;
 use crate::type_object::{PyDowncastImpl, PyTypeInfo};
-use crate::types::PyAny;
 use crate::types::PyTuple;
-use crate::{ffi, gil, Py, PyCell, PyClass, PyNativeType, PyRef, PyRefMut, Python};
+use crate::{ffi, gil, Py, PyAny, PyCell, PyClass, PyNativeType, PyRef, PyRefMut, Python};
 use std::ptr::NonNull;
 
 /// This trait represents that **we can do zero-cost conversion from the object

src/gil.rs

@@ -2,10 +2,7 @@
 
 //! Interaction with python's global interpreter lock
 
-use crate::ffi;
-use crate::internal_tricks::Unsendable;
-use crate::types::PyAny;
-use crate::Python;
+use crate::{ffi, internal_tricks::Unsendable, PyAny, Python};
 use std::ptr::NonNull;
 use std::{any, sync};
 

src/instance.rs

@@ -4,10 +4,9 @@ use crate::gil;
 use crate::object::PyObject;
 use crate::objectprotocol::ObjectProtocol;
 use crate::type_object::{PyBorrowFlagLayout, PyDowncastImpl};
-use crate::types::PyAny;
 use crate::{
-    ffi, AsPyPointer, FromPyObject, IntoPy, IntoPyPointer, PyCell, PyClass, PyClassInitializer,
-    PyRef, PyRefMut, PyTypeInfo, Python, ToPyObject,
+    ffi, AsPyPointer, FromPyObject, IntoPy, IntoPyPointer, PyAny, PyCell, PyClass,
+    PyClassInitializer, PyRef, PyRefMut, PyTypeInfo, Python, ToPyObject,
 };
 use std::marker::PhantomData;
 use std::mem;

src/lib.rs

@@ -148,6 +148,8 @@ pub use crate::pyclass::PyClass;
 pub use crate::pyclass_init::PyClassInitializer;
 pub use crate::python::{prepare_freethreaded_python, Python};
 pub use crate::type_object::{type_flags, PyTypeInfo};
+// Since PyAny is as important as PyObject, we expose it to the top level.
+pub use crate::types::PyAny;
 
 // Re-exported for wrap_function
 #[doc(hidden)]

src/prelude.rs

@@ -19,7 +19,7 @@ pub use crate::pycell::{PyCell, PyRef, PyRefMut};
 pub use crate::pyclass_init::PyClassInitializer;
 pub use crate::python::Python;
 pub use crate::{FromPy, FromPyObject, IntoPy, IntoPyPointer, PyTryFrom, PyTryInto, ToPyObject};
-// This is only part of the prelude because we need it for the pymodule function
-pub use crate::types::PyModule;
+// PyModule is only part of the prelude because we need it for the pymodule function
+pub use crate::types::{PyAny, PyModule};
 pub use pyo3cls::pymodule;
 pub use pyo3cls::{pyclass, pyfunction, pymethods, pyproto};

src/pycell.rs

@@ -3,8 +3,7 @@ use crate::conversion::{AsPyPointer, FromPyPointer, ToPyObject};
 use crate::pyclass_init::PyClassInitializer;
 use crate::pyclass_slots::{PyClassDict, PyClassWeakRef};
 use crate::type_object::{PyBorrowFlagLayout, PyDowncastImpl, PyLayout, PySizedLayout, PyTypeInfo};
-use crate::types::PyAny;
-use crate::{ffi, FromPy, PyClass, PyErr, PyNativeType, PyObject, PyResult, Python};
+use crate::{ffi, FromPy, PyAny, PyClass, PyErr, PyNativeType, PyObject, PyResult, Python};
 use std::cell::{Cell, UnsafeCell};
 use std::fmt;
 use std::mem::ManuallyDrop;

src/types/boolobject.rs

@@ -1,13 +1,9 @@
 // Copyright (c) 2017-present PyO3 Project and Contributors
-use crate::ffi;
 use crate::internal_tricks::Unsendable;
-use crate::object::PyObject;
-use crate::types::PyAny;
-use crate::FromPyObject;
-use crate::PyResult;
-use crate::Python;
-use crate::{AsPyPointer, FromPy};
-use crate::{PyTryFrom, ToPyObject};
+use crate::{
+    ffi, AsPyPointer, FromPy, FromPyObject, PyAny, PyObject, PyResult, PyTryFrom, Python,
+    ToPyObject,
+};
 
 /// Represents a Python `bool`.
 #[repr(transparent)]

src/types/bytes.rs

@@ -1,12 +1,8 @@
-use crate::conversion::FromPyObject;
-use crate::conversion::{PyTryFrom, ToPyObject};
-use crate::err::PyResult;
 use crate::internal_tricks::Unsendable;
-use crate::object::PyObject;
-use crate::types::PyAny;
-use crate::AsPyPointer;
-use crate::Python;
-use crate::{ffi, FromPy};
+use crate::{
+    ffi, AsPyPointer, FromPy, FromPyObject, PyAny, PyObject, PyResult, PyTryFrom, Python,
+    ToPyObject,
+};
 use std::ops::Index;
 use std::os::raw::c_char;
 use std::slice::SliceIndex;

src/types/complex.rs

@@ -133,10 +133,7 @@ impl<'py> Neg for &'py PyComplex {
 #[cfg(feature = "num-complex")]
 mod complex_conversion {
     use super::*;
-    use crate::err::PyErr;
-    use crate::types::PyAny;
-    use crate::PyResult;
-    use crate::{FromPyObject, ToPyObject};
+    use crate::{FromPyObject, PyAny, PyErr, PyResult, ToPyObject};
     use num_complex::Complex;
 
     impl PyComplex {

src/types/floatob.rs

@@ -1,19 +1,11 @@
 // Copyright (c) 2017-present PyO3 Project and Contributors
 //
 // based on Daniel Grunwald's https://github.com/dgrunwald/rust-cpython
-
-use crate::err::PyErr;
-use crate::ffi;
-use crate::instance::PyNativeType;
 use crate::internal_tricks::Unsendable;
-use crate::object::PyObject;
-use crate::objectprotocol::ObjectProtocol;
-use crate::types::PyAny;
-use crate::FromPyObject;
-use crate::PyResult;
-use crate::Python;
-use crate::ToPyObject;
-use crate::{AsPyPointer, FromPy};
+use crate::{
+    ffi, AsPyPointer, FromPy, FromPyObject, ObjectProtocol, PyAny, PyErr, PyNativeType, PyObject,
+    PyResult, Python, ToPyObject,
+};
 use std::os::raw::c_double;
 
 /// Represents a Python `float` object.

src/types/iterator.rs

@@ -2,12 +2,7 @@
 //
 // based on Daniel Grunwald's https://github.com/dgrunwald/rust-cpython
 
-use crate::err::{PyDowncastError, PyErr, PyResult};
-use crate::ffi;
-use crate::instance::PyNativeType;
-use crate::types::PyAny;
-use crate::AsPyPointer;
-use crate::Python;
+use crate::{ffi, AsPyPointer, PyAny, PyDowncastError, PyErr, PyNativeType, PyResult, Python};
 
 /// A Python iterator object.
 ///

src/types/list.rs

@@ -4,14 +4,11 @@
 
 use crate::err::{self, PyResult};
 use crate::ffi::{self, Py_ssize_t};
-use crate::instance::PyNativeType;
 use crate::internal_tricks::Unsendable;
-use crate::object::PyObject;
-use crate::types::PyAny;
-use crate::IntoPyPointer;
-use crate::Python;
-use crate::{AsPyPointer, IntoPy};
-use crate::{ToBorrowedObject, ToPyObject};
+use crate::{
+    AsPyPointer, IntoPy, IntoPyPointer, PyAny, PyNativeType, PyObject, Python, ToBorrowedObject,
+    ToPyObject,
+};
 
 /// Represents a Python `list`.
 #[repr(transparent)]