Implement exception introspection

Uses the new paste dependency (already used in ffi tests) to generate identifiers from proc-macros

Author: Tpt

Cargo.toml

@@ -60,7 +60,8 @@ smallvec = { version = "1.0", optional = true }
 uuid = { version = "1.11.0", optional = true }
 lock_api = { version = "0.4", optional = true }
 parking_lot = { version = "0.12", optional = true }
-iana-time-zone = { version = "0.1", optional = true, features = ["fallback"]}
+iana-time-zone = { version = "0.1", optional = true, features = ["fallback"] }
+paste = { version = "1", optional = true }
 
 [target.'cfg(not(target_has_atomic = "64"))'.dependencies]
 portable-atomic = "1.0"
@@ -93,7 +94,7 @@ experimental-async = ["macros", "pyo3-macros/experimental-async"]
 
 # Enables pyo3::inspect module and additional type information on FromPyObject
 # and IntoPy traits
-experimental-inspect = ["pyo3-macros/experimental-inspect"]
+experimental-inspect = ["pyo3-macros/experimental-inspect", "paste"]
 
 # Enables macros: #[pyclass], #[pymodule], #[pyfunction] etc.
 macros = ["pyo3-macros"]

newsfragments/5666.added.md

@@ -0,0 +1 @@
+Introspection: adds support for exception created using `create_exception!`

pytests/src/exception.rs

@@ -0,0 +1,19 @@
+use pyo3::create_exception;
+use pyo3::exceptions::{PyException, PyValueError};
+use pyo3::prelude::*;
+
+create_exception!(pyo3_pytests.exception, CustomValueError, PyValueError);
+
+create_exception!(pyo3_pytests.exception, CustomException, PyException);
+
+#[pymodule(gil_used = false)]
+pub mod exception {
+    #[pymodule_export]
+    use super::{CustomException, CustomValueError};
+    use pyo3::prelude::*;
+
+    #[pyfunction]
+    fn raise_custom_value_error() -> PyResult<()> {
+        Err(CustomValueError::new_err("custom value error"))
+    }
+}

pytests/src/lib.rs

@@ -9,6 +9,7 @@ mod consts;
 pub mod datetime;
 pub mod dict_iter;
 pub mod enums;
+mod exception;
 pub mod misc;
 pub mod objstore;
 pub mod othermod;
@@ -27,8 +28,8 @@ mod pyo3_pytests {
     use buf_and_str::buf_and_str;
     #[pymodule_export]
     use {
-        comparisons::comparisons, consts::consts, enums::enums, pyclasses::pyclasses,
-        pyfunctions::pyfunctions, subclassing::subclassing,
+        comparisons::comparisons, consts::consts, enums::enums, exception::exception,
+        pyclasses::pyclasses, pyfunctions::pyfunctions, subclassing::subclassing,
     };
 
     // Inserting to sys.modules allows importing submodules nicely from Python

pytests/stubs/exception.pyi

@@ -0,0 +1,6 @@
+from typing import Any
+
+class CustomException(Exception): ...
+class CustomValueError(ValueError): ...
+
+def raise_custom_value_error() -> Any: ...

src/exceptions.rs

@@ -230,9 +230,55 @@ macro_rules! create_exception_type_object {
                 ).as_ptr() as *mut $crate::ffi::PyTypeObject
             }
         }
+
+        $crate::create_exception_introspection_data!($module, $name, $base);
     };
 }
 
+/// Adds some introspection data for the exception if the `experimental-inspect` feature is enabled.
+#[cfg(not(feature = "experimental-inspect"))]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! create_exception_introspection_data(
+    ($module: expr, $name: ident, $base: ty) => {};
+);
+
+#[cfg(feature = "experimental-inspect")]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! create_exception_introspection_data(
+    ($module: expr, $name: ident, $base: ty) => {
+        const _: () = {
+            const PIECES: &[&[u8]] = &[
+                b"{\"type\":\"class\",\"id\":\"",
+                $name::_PYO3_INTROSPECTION_ID.as_bytes(),
+                b"\",\"name\":\"",
+                stringify!($name).as_bytes(),
+                b"\",\"bases\":[",
+                {
+                    const BASE_LEN: usize = $crate::inspect::serialized_len_for_introspection(&<$base as $crate::type_object::PyTypeInfo>::TYPE_HINT);
+                    const BASE_SER: [u8; BASE_LEN] = {
+                        let mut result: [u8; BASE_LEN] = [0; BASE_LEN];
+                        $crate::inspect::serialize_for_introspection(&<$base as $crate::type_object::PyTypeInfo>::TYPE_HINT, &mut result);
+                        result
+                    };
+                    &BASE_SER
+                },
+                b"]}"
+            ];
+            const PIECES_LEN: usize = $crate::impl_::concat::combined_len(PIECES);
+            $crate::impl_::introspection::paste! {
+                #[used]
+                #[no_mangle]
+                static [<PYO3_INTROSPECTION_1_ $name>]: $crate::impl_::introspection::SerializedIntrospectionFragment<PIECES_LEN> = $crate::impl_::introspection::SerializedIntrospectionFragment {
+                    length: PIECES_LEN as u32,
+                    fragment: $crate::impl_::concat::combine_to_array::<PIECES_LEN>(PIECES)
+                };
+            }
+        };
+    };
+);
+
 macro_rules! impl_native_exception (
     ($name:ident, $exc_name:ident, $python_name:expr, $doc:expr, $layout:path $(, #checkfunction=$checkfunction:path)?) => (
         #[doc = $doc]

src/impl_/introspection.rs

@@ -1,5 +1,6 @@
 use crate::conversion::IntoPyObject;
 use crate::inspect::TypeHint;
+pub use paste::paste;
 
 /// Trait to guess a function Python return type
 ///