also use PyErr::SetObject on Python versions before 3.12

newsfragments/3455.changed.md

@@ -0,0 +1 @@
+`Err` returned from `#[pyfunction]` will now have a non-None `__context__` if called from inside a `catch` block.

pytests/src/pyclasses.rs

@@ -58,10 +58,14 @@ impl AssertingBaseClass {
  }
 }
 
+#[pyclass]
+struct ClassWithoutConstructor;
+
 #[pymodule]
 pub fn pyclasses(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
  m.add_class::<EmptyClass>()?;
  m.add_class::<PyClassIter>()?;
  m.add_class::<AssertingBaseClass>()?;
+ m.add_class::<ClassWithoutConstructor>()?;
  Ok(())
 }

pytests/tests/test_pyclasses.py

@@ -1,3 +1,5 @@
+from typing import Type
+
 import pytest
 from pyo3_pytests import pyclasses
 
@@ -32,7 +34,29 @@ class AssertingSubClass(pyclasses.AssertingBaseClass):
 
 
 def test_new_classmethod():
- # The `AssertingBaseClass` constructor errors if it is not passed the relevant subclass.
+ # The `AssertingBaseClass` constructor errors if it is not passed the
+ # relevant subclass.
  _ = AssertingSubClass(expected_type=AssertingSubClass)
  with pytest.raises(ValueError):
  _ = AssertingSubClass(expected_type=str)
+
+
+class ClassWithoutConstructorPy:
+ def __new__(cls):
+ raise TypeError("No constructor defined")
+
+
+@pytest.mark.parametrize(
+ "cls", [pyclasses.ClassWithoutConstructor, ClassWithoutConstructorPy]
+)
+def test_no_constructor_defined_propagates_cause(cls: Type):
+ original_error = ValueError("Original message")
+ with pytest.raises(Exception) as exc_info:
+ try:
+ raise original_error
+ except Exception:
+ cls() # should raise TypeError("No constructor defined")
+
+ assert exc_info.type is TypeError
+ assert exc_info.value.args == ("No constructor defined",)
+ assert exc_info.value.__context__ is original_error

src/err/err_state.rs

@@ -1,5 +1,3 @@
-#[cfg(not(Py_3_12))]
-use crate::types::PyString;
 use crate::{
  exceptions::{PyBaseException, PyTypeError},
  ffi,
@@ -195,17 +193,14 @@ fn lazy_into_normalized_ffi_tuple(
  py: Python<'_>,
  lazy: Box<PyErrStateLazyFn>,
 ) -> (*mut ffi::PyObject, *mut ffi::PyObject, *mut ffi::PyObject) {
- let PyErrStateLazyFnOutput { ptype, pvalue } = lazy(py);
- let (mut ptype, mut pvalue) = if unsafe { ffi::PyExceptionClass_Check(ptype.as_ptr()) } == 0 {
- (
- PyTypeError::type_object_raw(py).cast(),
- PyString::new(py, "exceptions must derive from BaseException").into_ptr(),
- )
- } else {
- (ptype.into_ptr(), pvalue.into_ptr())
- };
+ // To be consistent with 3.12 logic, go via raise_lazy, but also then normalize
+ // the resulting exception
+ raise_lazy(py, lazy);
+ let mut ptype = std::ptr::null_mut();
+ let mut pvalue = std::ptr::null_mut();
  let mut ptraceback = std::ptr::null_mut();
  unsafe {
+ ffi::PyErr_Fetch(&mut ptype, &mut pvalue, &mut ptraceback);
  ffi::PyErr_NormalizeException(&mut ptype, &mut pvalue, &mut ptraceback);
  }
  (ptype, pvalue, ptraceback)
@@ -218,7 +213,6 @@ fn lazy_into_normalized_ffi_tuple(
 ///
 /// This would require either moving some logic from C to Rust, or requesting a new
 /// API in CPython.
-#[cfg(Py_3_12)]
 fn raise_lazy(py: Python<'_>, lazy: Box<PyErrStateLazyFn>) {
  let PyErrStateLazyFnOutput { ptype, pvalue } = lazy(py);
  unsafe {