Rename name to qualname and full_name to name to better match Python

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.added.md

@@ -1 +0,0 @@
-Added `PyType::full_name` which in contrast to `PyType::name` includes the module name.

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

@@ -9,7 +9,7 @@ fn issue_219() {
 
 #[pyfunction]
 fn get_type_full_name(obj: &PyAny) -> PyResult<Cow<'_, str>> {
-    obj.get_type().full_name()
+    obj.get_type().name()
 }
 
 #[pymodule]

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

@@ -33,13 +33,28 @@ impl PyType {
         py.from_borrowed_ptr(p as *mut ffi::PyObject)
     }
 
-    /// Gets the name of the `PyType`.
+    /// Gets the [qualified name](https://docs.python.org/3/glossary.html#term-qualified-name) of the `PyType`.
-    pub fn name(&self) -> PyResult<&str> {
+    pub fn qualname(&self) -> PyResult<String> {
-        self.getattr(intern!(self.py(), "__qualname__"))?.extract()
+        #[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 full_name(&self) -> PyResult<Cow<'_, str>> {
+    pub fn name(&self) -> PyResult<Cow<'_, str>> {
         #[cfg(not(any(Py_LIMITED_API, PyPy)))]
         {
             let name = unsafe { CStr::from_ptr((*self.as_type_ptr()).tp_name) }.to_str()?;
@@ -49,13 +64,17 @@ impl PyType {
 
         #[cfg(any(Py_LIMITED_API, PyPy))]
         {
-            let module = self
+            let module = self.getattr(intern!(self.py(), "__module__"))?;
-                .getattr(intern!(self.py(), "__module__"))?
-                .extract::<&str>()?;
 
-            let name = self
+            #[cfg(not(Py_3_11))]
-                .getattr(intern!(self.py(), "__name__"))?
+            let name = self.getattr(intern!(self.py(), "__name__"))?;
-                .extract::<&str>()?;
+
+            #[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)))
         }

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,