youknowone · Nov 12, 2026 · Nov 4, 2026 · Nov 5, 2026 · Nov 7, 2026 · Nov 7, 2026
diff --git a/Lib/test/test_cmd_line.py b/Lib/test/test_cmd_line.py
@@ -562,7 +562,6 @@ def test_unmached_quote(self):
         self.assertRegex(err.decode('ascii', 'ignore'), 'SyntaxError')
         self.assertEqual(b'', out)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     @force_not_colorized
     def test_stdout_flush_at_shutdown(self):
         # Issue #5319: if stdout.flush() fails at shutdown, an error should

diff --git a/crates/common/src/lock/thread_mutex.rs b/crates/common/src/lock/thread_mutex.rs
@@ -8,7 +8,7 @@ use core::{
     ptr::NonNull,
     sync::atomic::{AtomicUsize, Ordering},
 };
-use lock_api::{GetThreadId, GuardNoSend, RawMutex};
+use lock_api::{GetThreadId, GuardNoSend, RawMutex, RawMutexTimed};
 
 // based off ReentrantMutex from lock_api
 
@@ -175,6 +175,30 @@ impl<R: RawMutex, G: GetThreadId, T: ?Sized> ThreadMutex<R, G, T> {
     }
 }
 
+impl<R: RawMutexTimed, G: GetThreadId, T: ?Sized> ThreadMutex<R, G, T> {
+    /// Wait at most `timeout`, wrapping only the blocking acquisition.
+    pub fn try_lock_for_wrapped<F: FnOnce(&dyn Fn() -> bool) -> bool>(
+        &self,
+        timeout: R::Duration,
+        wrap_fn: F,
+    ) -> Result<ThreadMutexGuard<'_, R, G, T>, TryLockThreadError>
+    where
+        R::Duration: Copy,
+    {
+        match self
+            .raw
+            .lock_internal(|| wrap_fn(&|| self.raw.mutex.try_lock_for(timeout)))
+        {
+            Some(true) => Ok(ThreadMutexGuard {
+                mu: self,
+                marker: PhantomData,
+            }),
+            Some(false) => Err(TryLockThreadError::Other),
+            None => Err(TryLockThreadError::Current),
+        }
+    }
+}
+
 #[derive(Clone, Copy)]
 pub enum TryLockThreadError {
     /// Failed to lock because mutex was already locked on another thread.
@@ -353,3 +377,36 @@ impl<R: RawMutex, G: GetThreadId, T: ?Sized + fmt::Debug> fmt::Debug
         fmt::Debug::fmt(&**self, f)
     }
 }
+
+#[cfg(test)]
+#[cfg(feature = "threading")]
+mod tests {
+    use super::TryLockThreadError;
+    use crate::lock::PyThreadMutex;
+    use core::time::Duration;
+
+    #[test]
+    fn timed_lock_preserves_ownership() {
+        let mutex = PyThreadMutex::new(0);
+        let guard = mutex.lock().unwrap();
+        assert!(matches!(
+            mutex.try_lock_for_wrapped(Duration::ZERO, |_| panic!("reentrant wait")),
+            Err(TryLockThreadError::Current)
+        ));
+        std::thread::scope(|scope| {
+            scope.spawn(|| {
+                assert!(matches!(
+                    mutex.try_lock_for_wrapped(Duration::from_millis(1), |wait| wait()),
+                    Err(TryLockThreadError::Other)
+                ));
+            });
+        });
+        drop(guard);
+        let mut guard = mutex
+            .try_lock_for_wrapped(Duration::ZERO, |wait| wait())
+            .unwrap_or_else(|_| panic!("unlocked mutex"));
+        *guard = 1;
+        drop(guard);
+        assert_eq!(*mutex.lock().unwrap(), 1);
+    }
+}
diff --git a/crates/host_env/src/readline.rs b/crates/host_env/src/readline.rs
@@ -197,6 +197,84 @@ impl<H: Helper> Readline<H> {
     }
 }
 
+/// A nested readline must fail rather than consume the outer call's input.
+#[derive(Debug)]
+pub struct ReentrantReadline;
+
+#[derive(PartialEq, Eq)]
+struct TerminalIdentity {
+    streams: StreamIdentity,
+}
+
+#[cfg(unix)]
+type StreamIdentity = (libc::dev_t, libc::ino_t, libc::dev_t);
+#[cfg(windows)]
+type StreamIdentity = [usize; 2];
+#[cfg(not(any(unix, windows)))]
+type StreamIdentity = ();
+
+impl TerminalIdentity {
+    fn current() -> io::Result<Self> {
+        #[cfg(unix)]
+        let streams = {
+            let mut stat = core::mem::MaybeUninit::<libc::stat>::uninit();
+            // Only an input change invalidates read-ahead. Unix rustyline uses
+            // fd 1 directly, so an output-only change needs no new editor.
+            if unsafe { libc::fstat(0, stat.as_mut_ptr()) } != 0 {
+                return Err(io::Error::last_os_error());
+            }
+            let stat = unsafe { stat.assume_init() };
+            (stat.st_dev, stat.st_ino, stat.st_rdev)
+        };
+        #[cfg(windows)]
+        let streams = {
+            use windows_sys::Win32::System::Console::{STD_INPUT_HANDLE, STD_OUTPUT_HANDLE};
+            // Windows rustyline caches both handles, but has no read-ahead
+            // buffer (ConsoleRawReader::unbuffer returns None).
+            [
+                crate::winapi::get_std_handle(STD_INPUT_HANDLE)?.unwrap_or_default() as usize,
+                crate::winapi::get_std_handle(STD_OUTPUT_HANDLE)?.unwrap_or_default() as usize,
+            ]
+        };
+        #[cfg(not(any(unix, windows)))]
+        let streams = ();
+        Ok(Self { streams })
+    }
+}
+
+struct InputReader {
+    identity: TerminalIdentity,
+    reader: Readline<()>,
+}
+
+// stdin is process-wide, not thread-local. Retain read-ahead when the next
+// input() runs on another thread, and serialize the terminal's raw-mode guards.
+// A reentrant mutex plus a fallible borrow rejects same-thread recursion without
+// deadlocking. The reader contains no Python references or interpreter helper.
+static INPUT_READER: parking_lot::ReentrantMutex<core::cell::RefCell<Option<InputReader>>> =
+    parking_lot::ReentrantMutex::new(core::cell::RefCell::new(None));
+
+/// Read an interactive input line with the process's retained terminal reader.
+/// The VM must detach while waiting for both the lock and terminal input.
+pub fn input_readline(prompt: &str) -> Result<ReadlineResult, ReentrantReadline> {
+    let guard = INPUT_READER.lock();
+    let mut slot = guard.try_borrow_mut().map_err(|_| ReentrantReadline)?;
+    let identity = match TerminalIdentity::current() {
+        Ok(identity) => identity,
+        Err(error) => return Ok(ReadlineResult::Io(error)),
+    };
+    if slot
+        .as_ref()
+        .is_none_or(|reader| reader.identity != identity)
+    {
+        *slot = Some(InputReader {
+            identity,
+            reader: Readline::new(()),
+        });
+    }
+    Ok(slot.as_mut().unwrap().reader.readline(prompt))
+}
+
 /// Borrow the shared buffered stdin for one physical read. The caller retains
 /// partial bytes across EINTR and checks signals after this lock is released.
 pub fn stdio_readline_bytes(prompt: &str, line: &mut Vec<u8>) -> io::Result<usize> {
@@ -229,6 +307,16 @@ fn read_line_bytes(reader: &mut impl io::BufRead, line: &mut Vec<u8>) -> io::Res
 
 #[cfg(test)]
 mod tests {
+    #[test]
+    fn nested_input_is_rejected_before_touching_the_terminal() {
+        let guard = super::INPUT_READER.lock();
+        let _active_reader = guard.borrow_mut();
+        assert!(matches!(
+            super::input_readline(""),
+            Err(super::ReentrantReadline)
+        ));
+    }
+
     use super::read_line_bytes;
     use std::io::{self, BufRead, Read};
 

diff --git a/crates/vm/src/exceptions.rs b/crates/vm/src/exceptions.rs
@@ -213,12 +213,7 @@ impl VirtualMachine {
     /// Display `exc` through `traceback._print_exception_bltin`, falling back
     /// to the native printer writing to `file`.
     pub(crate) fn display_exception_to(&self, file: &PyObject, exc: &Py<PyBaseException>) {
-        if let Ok(print_exception) = self
-            .import("traceback", 0)
-            .and_then(|traceback| traceback.get_attr("_print_exception_bltin", self))
-            && print_exception.is_callable()
-            && print_exception.call((exc.to_owned(),), self).is_ok()
-        {
+        if self.try_display_exception_to(file, exc.as_object()) {
             return;
         }
         if self
@@ -231,6 +226,19 @@ impl VirtualMachine {
         let _ = self.call_method(file, "flush", ());
     }
 
+    /// Try the shared Python formatter with the caller's retained output file.
+    /// Reporting paths provide their own native fallback if it is unavailable.
+    pub(crate) fn try_display_exception_to(&self, file: &PyObject, exc: &PyObject) -> bool {
+        self.import("traceback", 0)
+            .and_then(|traceback| traceback.get_attr("_print_exception_bltin", self))
+            .is_ok_and(|print_exception| {
+                print_exception.is_callable()
+                    && print_exception
+                        .call((exc.to_owned(), file.to_owned()), self)
+                        .is_ok()
+            })
+    }
+
     pub fn write_exception<W: Write>(
         &self,
         output: &mut W,

diff --git a/crates/vm/src/object/core.rs b/crates/vm/src/object/core.rs
@@ -2195,7 +2195,7 @@ impl PyObject {
                             .repr(vm)
                             .ok()
                             .map(|r| format!("Exception ignored while calling deallocator {r}"));
-                        vm.run_unraisable(e, msg, del_method);
+                        vm.run_unraisable(e, msg, vm.ctx.none());
                     }
                 }
 
@@ -2368,7 +2368,7 @@ impl PyObject {
                         .repr(vm)
                         .ok()
                         .map(|r| format!("Exception ignored while calling deallocator {r}"));
-                    vm.run_unraisable(e, msg, del_method);
+                    vm.run_unraisable(e, msg, vm.ctx.none());
                 }
             });
             let _ = result;