Rename name to qualname and add name to better match Python and ensure abi3 fallbacks.

guide/src/class/numeric.md

@@ -232,7 +232,7 @@ impl Number {
 
     fn __repr__(slf: &PyCell<Self>) -> PyResult<String> {
        // Get the class name dynamically in case `Number` is subclassed
-       let class_name: &str = slf.get_type().name()?;
+       let class_name: String = slf.get_type().qualname()?;
         Ok(format!("{}({})", class_name, slf.borrow().0))
     }
 

guide/src/class/object.md

@@ -87,7 +87,7 @@ the subclass name. This is typically done in Python code by accessing
 impl Number {
     fn __repr__(slf: &PyCell<Self>) -> PyResult<String> {
         // This is the equivalent of `self.__class__.__name__` in Python.
-        let class_name: &str = slf.get_type().name()?;
+        let class_name: String = slf.get_type().qualname()?;
         // To access fields of the Rust struct, we need to borrow the `PyCell`.
         Ok(format!("{}({})", class_name, slf.borrow().0))
     }
@@ -263,7 +263,7 @@ impl Number {
     }
 
     fn __repr__(slf: &PyCell<Self>) -> PyResult<String> {
-        let class_name: &str = slf.get_type().name()?;
+        let class_name: String = slf.get_type().qualname()?;
         Ok(format!("{}({})", class_name, slf.borrow().0))
     }
 

guide/src/migration.md

@@ -74,6 +74,9 @@ Python::with_gil(|py| {
 });
 ```
 
+### `PyType::name` is now `PyType::qualname`
+
+`PyType::name` has been renamed to `PyType::qualname` to indicate that it does indeed return the [qualified name](https://docs.python.org/3/glossary.html#term-qualified-name), matching the `__qualname__` attribute. The newly added `PyType::name` yields the full name including the module name now which corresponds to `__module__.__name__` on the level of attributes.
 
 ## from 0.19.* to 0.20
 

newsfragments/3660.changed.md

@@ -0,0 +1 @@
+`PyType::name` is now `PyType::qualname` whereas `PyType::name` efficiently accesses the full name which includes the module name.

pytests/src/misc.rs

@@ -1,13 +1,20 @@
 use pyo3::prelude::*;
+use std::borrow::Cow;
 
 #[pyfunction]
 fn issue_219() {
     // issue 219: acquiring GIL inside #[pyfunction] deadlocks.
     Python::with_gil(|_| {});
 }
 
+#[pyfunction]
+fn get_type_full_name(obj: &PyAny) -> PyResult<Cow<'_, str>> {
+    obj.get_type().name()
+}
+
 #[pymodule]
 pub fn misc(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(issue_219, m)?)?;
+    m.add_function(wrap_pyfunction!(get_type_full_name, m)?)?;
     Ok(())
 }

pytests/tests/test_misc.py

@@ -48,3 +48,9 @@ def test_import_in_subinterpreter_forbidden():
         )
 
     _xxsubinterpreters.destroy(sub_interpreter)
+
+
+def test_type_full_name_includes_module():
+    numpy = pytest.importorskip("numpy")
+
+    assert pyo3_pytests.misc.get_type_full_name(numpy.bool_(True)) == "numpy.bool_"

src/err/mod.rs

@@ -706,7 +706,7 @@ impl std::fmt::Display for PyErr {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         Python::with_gil(|py| {
             let value = self.value(py);
-            let type_name = value.get_type().name().map_err(|_| std::fmt::Error)?;
+            let type_name = value.get_type().qualname().map_err(|_| std::fmt::Error)?;
             write!(f, "{}", type_name)?;
             if let Ok(s) = value.str() {
                 write!(f, ": {}", &s.to_string_lossy())
@@ -748,7 +748,8 @@ impl PyErrArguments for PyDowncastErrorArguments {
             "'{}' object cannot be converted to '{}'",
             self.from
                 .as_ref(py)
-                .name()
+                .qualname()
+                .as_deref()
                 .unwrap_or("<failed to extract type name>"),
             self.to
         )
@@ -775,7 +776,10 @@ impl<'a> std::fmt::Display for PyDowncastError<'a> {
         write!(
             f,
             "'{}' object cannot be converted to '{}'",
-            self.from.get_type().name().map_err(|_| std::fmt::Error)?,
+            self.from
+                .get_type()
+                .qualname()
+                .map_err(|_| std::fmt::Error)?,
             self.to
         )
     }

src/types/typeobject.rs

@@ -1,5 +1,8 @@
 use crate::err::{self, PyResult};
 use crate::{ffi, PyAny, PyTypeInfo, Python};
+use std::borrow::Cow;
+#[cfg(not(any(Py_LIMITED_API, PyPy)))]
+use std::ffi::CStr;
 
 /// Represents a reference to a Python `type object`.
 #[repr(transparent)]
@@ -30,9 +33,58 @@ impl PyType {
         py.from_borrowed_ptr(p as *mut ffi::PyObject)
     }
 
-    /// Gets the name of the `PyType`.
-    pub fn name(&self) -> PyResult<&str> {
-        self.getattr(intern!(self.py(), "__qualname__"))?.extract()
+    /// Gets the [qualified name](https://docs.python.org/3/glossary.html#term-qualified-name) of the `PyType`.
+    pub fn qualname(&self) -> PyResult<String> {
+        #[cfg(any(Py_LIMITED_API, PyPy, not(Py_3_11)))]
+        let name = self.getattr(intern!(self.py(), "__qualname__"))?.extract();
+
+        #[cfg(not(any(Py_LIMITED_API, PyPy, not(Py_3_11))))]
+        let name = {
+            use crate::ffi_ptr_ext::FfiPtrExt;
+            use crate::types::any::PyAnyMethods;
+
+            let obj = unsafe {
+                ffi::PyType_GetQualName(self.as_type_ptr()).assume_owned_or_err(self.py())?
+            };
+
+            obj.extract()
+        };
+
+        name
+    }
+
+    /// Gets the full name, which includes the module, of the `PyType`.
+    pub fn name(&self) -> PyResult<Cow<'_, str>> {
+        #[cfg(not(any(Py_LIMITED_API, PyPy)))]
+        {
+            let ptr = self.as_type_ptr();
+
+            let name = unsafe { CStr::from_ptr((*ptr).tp_name) }.to_str()?;
+
+            #[cfg(Py_3_10)]
+            if unsafe { ffi::PyType_HasFeature(ptr, ffi::Py_TPFLAGS_IMMUTABLETYPE) } != 0 {
+                return Ok(Cow::Borrowed(name));
+            }
+
+            Ok(Cow::Owned(name.to_owned()))
+        }
+
+        #[cfg(any(Py_LIMITED_API, PyPy))]
+        {
+            let module = self.getattr(intern!(self.py(), "__module__"))?;
+
+            #[cfg(not(Py_3_11))]
+            let name = self.getattr(intern!(self.py(), "__name__"))?;
+
+            #[cfg(Py_3_11)]
+            let name = {
+                use crate::ffi_ptr_ext::FfiPtrExt;
+
+                unsafe { ffi::PyType_GetName(self.as_type_ptr()).assume_owned_or_err(self.py())? }
+            };
+
+            Ok(Cow::Owned(format!("{}.{}", module, name)))
+        }
     }
 
     /// Checks whether `self` is a subclass of `other`.

tests/test_coroutine.rs

@@ -136,7 +136,10 @@ fn cancelled_coroutine() {
                 None,
             )
             .unwrap_err();
-        assert_eq!(err.value(gil).get_type().name().unwrap(), "CancelledError");
+        assert_eq!(
+            err.value(gil).get_type().qualname().unwrap(),
+            "CancelledError"
+        );
     })
 }
 

tests/test_methods.rs

@@ -74,14 +74,14 @@ impl ClassMethod {
     #[classmethod]
     /// Test class method.
     fn method(cls: &PyType) -> PyResult<String> {
-        Ok(format!("{}.method()!", cls.name()?))
+        Ok(format!("{}.method()!", cls.qualname()?))
     }
 
     #[classmethod]
     fn method_owned(cls: Py<PyType>) -> PyResult<String> {
         Ok(format!(
             "{}.method_owned()!",
-            Python::with_gil(|gil| cls.as_ref(gil).name().map(ToString::to_string))?
+            Python::with_gil(|gil| cls.as_ref(gil).qualname())?
         ))
     }
 }
@@ -109,7 +109,7 @@ struct ClassMethodWithArgs {}
 impl ClassMethodWithArgs {
     #[classmethod]
     fn method(cls: &PyType, input: &PyString) -> PyResult<String> {
-        Ok(format!("{}.method({})", cls.name()?, input))
+        Ok(format!("{}.method({})", cls.qualname()?, input))
     }
 }
 
@@ -937,7 +937,7 @@ impl r#RawIdents {
 fn test_raw_idents() {
     Python::with_gil(|py| {
         let raw_idents_type = py.get_type::<r#RawIdents>();
-        assert_eq!(raw_idents_type.name().unwrap(), "RawIdents");
+        assert_eq!(raw_idents_type.qualname().unwrap(), "RawIdents");
         py_run!(
             py,
             raw_idents_type,