Method set_exception

crates/stdlib/src/_asyncio.rs:280–330

(
            zelf: PyRef<Self>,
            exception: PyObjectRef,
            vm: &VirtualMachine,
        )

        #[pymethod]
        fn set_exception(
            zelf: PyRef<Self>,
            exception: PyObjectRef,
            vm: &VirtualMachine,
        ) -> PyResult<()> {
            if zelf.fut_loop.read().is_none() {
                return Err(vm.new_runtime_error("Future object is not initialized."));
            }
            if zelf.fut_state.load() != FutureState::Pending {
                return Err(new_invalid_state_error(vm, "invalid state"));
            }

            // Normalize the exception
            let exc = if exception.fast_isinstance(vm.ctx.types.type_type) {
                exception.call((), vm)?
            } else {
                exception
            };

            if !exc.fast_isinstance(vm.ctx.exceptions.base_exception_type) {
                return Err(vm.new_type_error(format!(
                    "exception must be a BaseException, not {}",
                    exc.class().name()
                )));
            }

            // Wrap StopIteration in RuntimeError
            let exc = if exc.fast_isinstance(vm.ctx.exceptions.stop_iteration) {
                let msg = "StopIteration interacts badly with generators and cannot be raised into a Future";
                let runtime_err = vm.new_runtime_error(msg.to_string());
                // Set cause and context to the original StopIteration
                let stop_iter: PyRef<PyBaseException> = exc.downcast().unwrap();
                runtime_err.set___cause__(Some(stop_iter.clone()));
                runtime_err.set___context__(Some(stop_iter));
                runtime_err.into()
            } else {
                exc
            };

            // Save the original traceback for later restoration
            if let Ok(exc_ref) = exc.clone().downcast::<PyBaseException>() {
                let tb = exc_ref.__traceback__().map(|tb| tb.into());
                *zelf.fut_exception_tb.write() = tb;
            }

            *zelf.fut_exception.write() = Some(exc);
            zelf.fut_state.store(FutureState::Finished);
            zelf.fut_log_tb.store(true, Ordering::Relaxed);
            Self::schedule_callbacks(&zelf, vm)?;
            Ok(())
        }

        #[pymethod]
        fn add_done_callback(