Rename PyAny -> PyObject

Author: davidhewitt

examples/rustapi_module/src/objstore.rs

@@ -3,7 +3,7 @@ use pyo3::prelude::*;
 #[pyclass]
 #[derive(Default)]
 pub struct ObjStore {
-    obj: Vec<Py<PyAny>>,
+    obj: Vec<Py<PyObject>>,
 }
 
 #[pymethods]
@@ -13,7 +13,7 @@ impl ObjStore {
         ObjStore::default()
     }
 
-    fn push(&mut self, py: Python, obj: &PyAny) {
+    fn push(&mut self, py: Python, obj: &PyObject) {
         self.obj.push(obj.to_object(py).into());
     }
 }

guide/src/class.md

@@ -32,8 +32,8 @@ impl pyo3::pyclass::PyClassAlloc for MyClass {}
 
 unsafe impl pyo3::PyTypeInfo for MyClass {
     type Type = MyClass;
-    type BaseType = PyAny;
-    type BaseLayout = pyo3::pycell::PyCellBase<PyAny>;
+    type BaseType = PyObject;
+    type BaseLayout = pyo3::pycell::PyCellBase<PyObject>;
     type Layout = PyCell<Self>;
     type Initializer = PyClassInitializer<Self>;
     type AsRefTarget = PyCell<Self>;
@@ -54,7 +54,7 @@ unsafe impl pyo3::PyTypeInfo for MyClass {
 impl pyo3::pyclass::PyClass for MyClass {
     type Dict = pyo3::pyclass_slots::PyClassDummySlot;
     type WeakRef = pyo3::pyclass_slots::PyClassDummySlot;
-    type BaseNativeType = PyAny;
+    type BaseNativeType = PyObject;
 }
 
 impl pyo3::IntoPy<PyObject> for MyClass {
@@ -240,7 +240,7 @@ Consult the table below to determine which type your constructor should return:
 
 ## Inheritance
 
-By default, `PyAny` is used as the base class. To override this default,
+By default, `PyObject` is used as the base class. To override this default,
 use the `extends` parameter for `pyclass` with the full path to the base class.
 
 For convenience, `(T, U)` implements `Into<PyClassInitializer<T>>` where `U` is the
@@ -340,7 +340,7 @@ impl DictWithCounter {
     fn new() -> Self {
         Self::default()
     }
-    fn set(mut self_: PyRefMut<Self>, key: String, value: &PyAny) -> PyResult<()> {
+    fn set(mut self_: PyRefMut<Self>, key: String, value: &PyObject) -> PyResult<()> {
         self_.counter.entry(key.clone()).or_insert(0);
         let py = self_.py();
         let dict: &PyDict = unsafe { py.from_borrowed_ptr_or_err(self_.as_ptr())? };

guide/src/python_from_rust.md

@@ -7,7 +7,7 @@ PyO3 is built for an extension module or not.
 
 [`Python::eval`](https://pyo3.rs/master/doc/pyo3/struct.Python.html#method.eval) is
 a method to execute a [Python expression](https://docs.python.org/3.7/reference/expressions.html)
-and return the evaluated value as a `&PyAny` object.
+and return the evaluated value as a `&PyObject` object.
 
 ```rust
 use pyo3::prelude::*;

guide/src/rust_cpython.md

@@ -69,7 +69,7 @@ impl PyList {
 
    fn new(py: Python) -> &PyList {...}
 
-   fn get_item(&self, index: isize) -> &PyAny {...}
+   fn get_item(&self, index: isize) -> &PyObject {...}
 }
 ```
 

guide/src/types.md

@@ -26,7 +26,7 @@ In PyO3, holding the GIL is modeled by acquiring a token of the type
 * It can be passed to functions that require a proof of holding the GIL,
   such as [`PyObject::clone_ref`][clone_ref].
 * Its lifetime can be used to create Rust references that implicitly guarantee
-  holding the GIL, such as [`&'py PyAny`][PyAny].
+  holding the GIL, such as [`&'py PyObject`][PyObject].
 
 The latter two points are the reason why some APIs in PyO3 require the `py:
 Python` argument, while others don't.
@@ -60,7 +60,7 @@ Can be cloned using Python reference counts with `.clone_ref()`.
 
 **Conversions:**
 
-- To `&PyAny`: `obj.as_ref(py)`
+- To `&PyObject`: `obj.as_ref(py)`
 - To `Py<ConcreteType>`: `obj.as_ref(py).extract::<Py<ConcreteType>>`
 - To `&ConcreteType` (which must be a Python native type): `obj.cast_as(py)`
 
@@ -80,15 +80,15 @@ implemented in Rust.
   implemented in Rust, you get a `PyCell` (see below).  For Python native types,
   mutating operations through PyO3's API don't require `&mut` access.
 
-**Note:** `PyObject` is semantically equivalent to `Py<PyAny>` and might be
+**Note:** `PyObject` is semantically equivalent to `Py<PyObject>` and might be
 merged with it in the future.
 
 
-### `PyAny`
+### `PyObject`
 
 **Represents:** a Python object of unspecified type, restricted to a GIL
-lifetime.  Currently, `PyAny` can only ever occur as a reference, usually
-`&PyAny`.
+lifetime.  Currently, `PyObject` can only ever occur as a reference, usually
+`&PyObject`.
 
 **Used:** Whenever you want to refer to some Python object only as long as
 holding the GIL.  For example, intermediate values and arguments to
@@ -102,15 +102,15 @@ holding the GIL.  For example, intermediate values and arguments to
 ### `PyTuple`, `PyDict`, and many more
 
 **Represents:** a native Python object of known type, restricted to a GIL
-lifetime just like `PyAny`.
+lifetime just like `PyObject`.
 
 **Used:** Whenever you want to operate with native Python types while holding
-the GIL.  Like `PyAny`, this is the most convenient form to use for function
+the GIL.  Like `PyObject`, this is the most convenient form to use for function
 arguments and intermediate values.
 
 **Conversions:**
 
-- To `PyAny`: `obj.as_ref()`
+- To `PyObject`: `obj.as_ref()`
 - To `Py<T>`: `Py::from(obj)`
 
 
@@ -126,7 +126,7 @@ Rust references.
 
 **Conversions:**
 
-- From `PyAny`: `.downcast()`
+- From `PyObject`: `.downcast()`
 
 
 ### `PyRef<SomeType>` and `PyRefMut<SomeType>`
@@ -135,7 +135,7 @@ Rust references.
 borrows, analog to `Ref` and `RefMut` used by `RefCell`.
 
 **Used:** while borrowing a `PyCell`.  They can also be used with `.extract()`
-on types like `Py<T>` and `PyAny` to get a reference quickly.
+on types like `Py<T>` and `PyObject` to get a reference quickly.
 
 
 
@@ -154,6 +154,6 @@ This trait marks structs that mirror native Python types, such as `PyList`.
 
 [eval]: https://docs.rs/pyo3/latest/pyo3/struct.Python.html#method.eval
 [clone_ref]: https://docs.rs/pyo3/latest/pyo3/struct.PyObject.html#method.clone_ref
-[PyAny]: https://docs.rs/pyo3/latest/pyo3/types/struct.PyAny.html
+[PyObject]: https://docs.rs/pyo3/latest/pyo3/types/struct.PyObject.html
 [PyList_append]: https://docs.rs/pyo3/latest/pyo3/types/struct.PyList.html#method.append
 [RefCell]: https://doc.rust-lang.org/std/cell/struct.RefCell.html

pyo3-derive-backend/src/module.rs

@@ -178,7 +178,7 @@ pub fn add_fn_to_module(
     let wrapper = function_c_wrapper(&func.sig.ident, &spec);
 
     Ok(quote! {
-        fn #function_wrapper_ident(py: pyo3::Python) -> pyo3::Py<pyo3::PyAny> {
+        fn #function_wrapper_ident(py: pyo3::Python) -> pyo3::Py<pyo3::PyObject> {
             #wrapper
 
             let _def = pyo3::class::PyMethodDef {

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::PyAny },
+            base: parse_quote! { pyo3::PyObject },
             has_extends: false,
         }
     }
@@ -357,19 +357,19 @@ 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::PyAny> }
+        quote! { pyo3::pycell::PyCellBase<pyo3::PyObject> }
     };
     let base_nativetype = if attr.has_extends {
         quote! { <Self::BaseType as pyo3::derive_utils::PyBaseTypeUtils>::BaseNativeType }
     } else {
-        quote! { pyo3::PyAny }
+        quote! { pyo3::PyObject }
     };
 
-    // If #cls is not extended type, we allow Self->Py<PyAny> conversion
+    // If #cls is not extended type, we allow Self->Py<PyObject> conversion
     let into_pyobject = if !attr.has_extends {
         quote! {
-            impl pyo3::IntoPy<Py<PyAny>> for #cls {
-                fn into_py(self, py: pyo3::Python) -> pyo3::Py<PyAny> {
+            impl pyo3::IntoPy<Py<PyObject>> for #cls {
+                fn into_py(self, py: pyo3::Python) -> pyo3::Py<PyObject> {
                     pyo3::IntoPy::into_py(pyo3::Py::new(py, self).unwrap(), py)
                 }
             }

pyo3-derive-backend/src/pymethod.rs

@@ -377,7 +377,7 @@ pub(crate) fn impl_wrap_setter(
                 let _pool = pyo3::GILPool::new(_py);
                 let _slf = _py.from_borrowed_ptr::<pyo3::PyCell<#cls>>(_slf);
                 #borrow_self
-                let _value = _py.from_borrowed_ptr::<pyo3::types::PyAny>(_value);
+                let _value = _py.from_borrowed_ptr::<pyo3::types::PyObject>(_value);
                 let _val = pyo3::FromPyObject::extract(_value)?;
                 pyo3::callback::convert(_py, {#setter_impl})
             })

src/buffer.rs

@@ -18,7 +18,7 @@
 
 //! `PyBuffer` implementation
 use crate::err::{self, PyResult};
-use crate::{exceptions, ffi, AsPyPointer, PyAny, Python};
+use crate::{exceptions, ffi, AsPyPointer, PyObject, Python};
 use std::ffi::CStr;
 use std::os::raw;
 use std::pin::Pin;
@@ -160,7 +160,7 @@ fn validate(b: &ffi::Py_buffer) {
 
 impl PyBuffer {
     /// Get the underlying buffer from the specified python object.
-    pub fn get(py: Python, obj: &PyAny) -> PyResult<PyBuffer> {
+    pub fn get(py: Python, obj: &PyObject) -> PyResult<PyBuffer> {
         unsafe {
             let mut buf = Box::pin(mem::zeroed::<ffi::Py_buffer>());
             err::error_on_minusone(

src/callback.rs

@@ -6,7 +6,7 @@ use crate::err::PyResult;
 use crate::exceptions::OverflowError;
 use crate::ffi::{self, Py_hash_t};
 use crate::IntoPyPointer;
-use crate::{IntoPy, PyAny, Py, Python};
+use crate::{IntoPy, PyObject, Py, Python};
 use std::isize;
 use std::os::raw::c_int;
 
@@ -48,7 +48,7 @@ where
 
 impl<T> IntoPyCallbackOutput<*mut ffi::PyObject> for T
 where
-    T: IntoPy<Py<PyAny>>,
+    T: IntoPy<Py<PyObject>>,
 {
     fn convert(self, py: Python) -> PyResult<*mut ffi::PyObject> {
         Ok(self.into_py(py).into_ptr())

src/class/basic.rs

@@ -11,7 +11,7 @@
 use crate::callback::HashCallbackOutput;
 use crate::class::methods::PyMethodDef;
 use crate::{
-    callback, exceptions, ffi, run_callback, FromPyObject, GILPool, IntoPy, ObjectProtocol, PyAny,
+    callback, exceptions, ffi, run_callback, FromPyObject, GILPool, IntoPy, ObjectProtocol, PyObject,
     PyCell, PyClass, PyErr, Py, PyResult, Python,
 };
 use std::os::raw::c_int;
@@ -103,7 +103,7 @@ pub trait PyObjectProtocol<'p>: PyClass {
 
 pub trait PyObjectGetAttrProtocol<'p>: PyObjectProtocol<'p> {
     type Name: FromPyObject<'p>;
-    type Success: IntoPy<Py<PyAny>>;
+    type Success: IntoPy<Py<PyObject>>;
     type Result: Into<PyResult<Self::Success>>;
 }
 pub trait PyObjectSetAttrProtocol<'p>: PyObjectProtocol<'p> {
@@ -116,16 +116,16 @@ pub trait PyObjectDelAttrProtocol<'p>: PyObjectProtocol<'p> {
     type Result: Into<PyResult<()>>;
 }
 pub trait PyObjectStrProtocol<'p>: PyObjectProtocol<'p> {
-    type Success: IntoPy<Py<PyAny>>;
+    type Success: IntoPy<Py<PyObject>>;
     type Result: Into<PyResult<Self::Success>>;
 }
 pub trait PyObjectReprProtocol<'p>: PyObjectProtocol<'p> {
-    type Success: IntoPy<Py<PyAny>>;
+    type Success: IntoPy<Py<PyObject>>;
     type Result: Into<PyResult<Self::Success>>;
 }
 pub trait PyObjectFormatProtocol<'p>: PyObjectProtocol<'p> {
     type Format: FromPyObject<'p>;
-    type Success: IntoPy<Py<PyAny>>;
+    type Success: IntoPy<Py<PyObject>>;
     type Result: Into<PyResult<Self::Success>>;
 }
 pub trait PyObjectHashProtocol<'p>: PyObjectProtocol<'p> {
@@ -135,12 +135,12 @@ pub trait PyObjectBoolProtocol<'p>: PyObjectProtocol<'p> {
     type Result: Into<PyResult<bool>>;
 }
 pub trait PyObjectBytesProtocol<'p>: PyObjectProtocol<'p> {
-    type Success: IntoPy<Py<PyAny>>;
+    type Success: IntoPy<Py<PyObject>>;
     type Result: Into<PyResult<Self::Success>>;
 }
 pub trait PyObjectRichcmpProtocol<'p>: PyObjectProtocol<'p> {
     type Other: FromPyObject<'p>;
-    type Success: IntoPy<Py<PyAny>>;
+    type Success: IntoPy<Py<PyObject>>;
     type Result: Into<PyResult<Self::Success>>;
 }
 
@@ -233,7 +233,7 @@ where
                 }
 
                 let slf = py.from_borrowed_ptr::<PyCell<T>>(slf);
-                let arg = py.from_borrowed_ptr::<PyAny>(arg);
+                let arg = py.from_borrowed_ptr::<PyObject>(arg);
                 callback::convert(py, call_ref!(slf, __getattr__, arg))
             })
         }
@@ -489,7 +489,7 @@ where
             run_callback(py, || {
                 let _pool = GILPool::new(py);
                 let slf = py.from_borrowed_ptr::<crate::PyCell<T>>(slf);
-                let arg = py.from_borrowed_ptr::<PyAny>(arg);
+                let arg = py.from_borrowed_ptr::<PyObject>(arg);
 
                 let borrowed_slf = slf.try_borrow()?;
                 let op = extract_op(op)?;

src/class/context.rs

@@ -6,7 +6,7 @@
 
 use crate::class::methods::PyMethodDef;
 use crate::err::PyResult;
-use crate::{PyClass, Py, PyAny};
+use crate::{PyClass, Py, PyObject};
 
 /// Context manager interface
 #[allow(unused_variables)]
@@ -32,15 +32,15 @@ pub trait PyContextProtocol<'p>: PyClass {
 }
 
 pub trait PyContextEnterProtocol<'p>: PyContextProtocol<'p> {
-    type Success: crate::IntoPy<Py<PyAny>>;
+    type Success: crate::IntoPy<Py<PyObject>>;
     type Result: Into<PyResult<Self::Success>>;
 }
 
 pub trait PyContextExitProtocol<'p>: PyContextProtocol<'p> {
     type ExcType: crate::FromPyObject<'p>;
     type ExcValue: crate::FromPyObject<'p>;
     type Traceback: crate::FromPyObject<'p>;
-    type Success: crate::IntoPy<Py<PyAny>>;
+    type Success: crate::IntoPy<Py<PyObject>>;
     type Result: Into<PyResult<Self::Success>>;
 }
 

src/class/descr.rs

@@ -7,35 +7,35 @@
 
 use crate::class::methods::PyMethodDef;
 use crate::err::PyResult;
-use crate::types::{PyAny, PyType};
+use crate::types::{PyObject, PyType};
 use crate::{ffi, FromPyObject, IntoPy, PyClass, Py};
 use std::os::raw::c_int;
 
 /// Descriptor interface
 #[allow(unused_variables)]
 pub trait PyDescrProtocol<'p>: PyClass {
-    fn __get__(&'p self, instance: &'p PyAny, owner: Option<&'p PyType>) -> Self::Result
+    fn __get__(&'p self, instance: &'p PyObject, owner: Option<&'p PyType>) -> Self::Result
     where
         Self: PyDescrGetProtocol<'p>,
     {
         unimplemented!()
     }
 
-    fn __set__(&'p self, instance: &'p PyAny, value: &'p PyAny) -> Self::Result
+    fn __set__(&'p self, instance: &'p PyObject, value: &'p PyObject) -> Self::Result
     where
         Self: PyDescrSetProtocol<'p>,
     {
         unimplemented!()
     }
 
-    fn __delete__(&'p self, instance: &'p PyAny) -> Self::Result
+    fn __delete__(&'p self, instance: &'p PyObject) -> Self::Result
     where
         Self: PyDescrDeleteProtocol<'p>,
     {
         unimplemented!()
     }
 
-    fn __set_name__(&'p self, instance: &'p PyAny) -> Self::Result
+    fn __set_name__(&'p self, instance: &'p PyObject) -> Self::Result
     where
         Self: PyDescrSetNameProtocol<'p>,
     {
@@ -46,7 +46,7 @@ pub trait PyDescrProtocol<'p>: PyClass {
 pub trait PyDescrGetProtocol<'p>: PyDescrProtocol<'p> {
     type Inst: FromPyObject<'p>;
     type Owner: FromPyObject<'p>;
-    type Success: IntoPy<Py<PyAny>>;
+    type Success: IntoPy<Py<PyObject>>;
     type Result: Into<PyResult<Self::Success>>;
 }