RustPython · youknowone · May 20, 2026 · May 16, 2026 · May 16, 2026 · May 16, 2026
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Lib/test/test_format.py b/Lib/test/test_format.py
@@ -423,7 +423,6 @@ def test_non_ascii(self):
         self.assertEqual(format(1+2j, "\u2007^8"), "\u2007(1+2j)\u2007")
         self.assertEqual(format(0j, "\u2007^4"), "\u20070j\u2007")
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; AssertionError: ',' not found in '123456789'")
     def test_locale(self):
         try:
             oldloc = locale.setlocale(locale.LC_ALL)

diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
@@ -431,7 +431,6 @@ def test(i, format_spec, result):
         test(123456, "1=20", '11111111111111123456')
         test(123456, "*=20", '**************123456')
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; AssertionError: '1,234.57' != '1234.57'")
     @run_with_locale('LC_NUMERIC', 'en_US.UTF8', '')
     def test_float__format__locale(self):
         # test locale support for __format__ code 'n'
@@ -441,7 +440,6 @@ def test_float__format__locale(self):
             self.assertEqual(locale.format_string('%g', x, grouping=True), format(x, 'n'))
             self.assertEqual(locale.format_string('%.10g', x, grouping=True), format(x, '.10n'))
 
-    @unittest.expectedFailureIfWindows("TODO: RUSTPYTHON; AssertionError: '123,456,789,012,345,678,901,234,567,890' != '123456789012345678901234567890'")
     @run_with_locale('LC_NUMERIC', 'en_US.UTF8', '')
     def test_int__format__locale(self):
         # test locale support for __format__ code 'n' for integers

diff --git a/crates/host_env/Cargo.toml b/crates/host_env/Cargo.toml
@@ -12,6 +12,7 @@ license.workspace = true
 rustpython-wtf8 = { workspace = true }
 
 bitflags = { workspace = true }
+getrandom = { workspace = true }
 libc = { workspace = true }
 num-traits = { workspace = true }
 parking_lot = { workspace = true }

diff --git a/crates/host_env/src/errno.rs b/crates/host_env/src/errno.rs
@@ -1,5 +1,18 @@
 // spell-checker:disable
 
+/// Return the platform `strerror(errno)` message as an owned `String`.
+/// Returns `None` when the runtime gives no description for `errno`.
+#[cfg(any(unix, windows))]
+#[must_use]
+pub fn strerror_string(errno: i32) -> Option<String> {
+    let ptr = unsafe { libc::strerror(errno) };
+    if ptr.is_null() {
+        return None;
+    }
+    let s = unsafe { core::ffi::CStr::from_ptr(ptr) }.to_string_lossy();
+    Some(s.into_owned())
+}
+
 #[cfg(any(unix, windows, target_os = "wasi"))]
 pub mod errors {
     pub use libc::*;

diff --git a/crates/host_env/src/fcntl.rs b/crates/host_env/src/fcntl.rs
@@ -3,17 +3,14 @@ use std::io;
 #[cfg(unix)]
 use std::os::fd::BorrowedFd;
 
+use crate::os::CheckLibcResult;
+
 pub fn normalize_ioctl_request(request: i64) -> libc::c_ulong {
     (request as u32) as libc::c_ulong
 }
 
 pub fn fcntl_int(fd: i32, cmd: i32, arg: i32) -> io::Result<i32> {
-    let ret = unsafe { libc::fcntl(fd, cmd, arg) };
-    if ret < 0 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(ret)
-    }
+    unsafe { libc::fcntl(fd, cmd, arg) }.check_libc_neg()
 }
 
 pub fn validate_fd(fd: i32) -> io::Result<()> {
@@ -56,12 +53,7 @@ pub fn set_blocking(fd: BorrowedFd<'_>, blocking: bool) -> io::Result<()> {
 }
 
 pub fn fcntl_with_bytes(fd: i32, cmd: i32, arg: &mut [u8]) -> io::Result<i32> {
-    let ret = unsafe { libc::fcntl(fd, cmd, arg.as_mut_ptr()) };
-    if ret < 0 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(ret)
-    }
+    unsafe { libc::fcntl(fd, cmd, arg.as_mut_ptr()) }.check_libc_neg()
 }
 
 /// # Safety
@@ -73,31 +65,16 @@ pub unsafe fn ioctl_ptr(
     request: libc::c_ulong,
     arg: *mut libc::c_void,
 ) -> io::Result<i32> {
-    let ret = unsafe { libc::ioctl(fd, request as _, arg) };
-    if ret < 0 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(ret)
-    }
+    unsafe { libc::ioctl(fd, request as _, arg) }.check_libc_neg()
 }
 
 pub fn ioctl_int(fd: i32, request: libc::c_ulong, arg: i32) -> io::Result<i32> {
-    let ret = unsafe { libc::ioctl(fd, request as _, arg) };
-    if ret < 0 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(ret)
-    }
+    unsafe { libc::ioctl(fd, request as _, arg) }.check_libc_neg()
 }
 
 #[cfg(not(any(target_os = "wasi", target_os = "redox")))]
 pub fn flock(fd: i32, operation: i32) -> io::Result<i32> {
-    let ret = unsafe { libc::flock(fd, operation) };
-    if ret < 0 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(ret)
-    }
+    unsafe { libc::flock(fd, operation) }.check_libc_neg()
 }
 
 #[cfg(not(any(target_os = "wasi", target_os = "redox")))]
@@ -137,7 +114,7 @@ pub fn lockf(fd: i32, cmd: i32, len: i64, start: i64, whence: i32) -> Result<i32
         ..unsafe { core::mem::zeroed() }
     };
 
-    let ret = unsafe {
+    unsafe {
         libc::fcntl(
             fd,
             if (cmd & libc::LOCK_NB) != 0 {
@@ -147,10 +124,7 @@ pub fn lockf(fd: i32, cmd: i32, len: i64, start: i64, whence: i32) -> Result<i32
             },
             &lock,
         )
-    };
-    if ret < 0 {
-        Err(LockfError::Io(io::Error::last_os_error()))
-    } else {
-        Ok(ret)
     }
+    .check_libc_neg()
+    .map_err(LockfError::Io)
 }
diff --git a/crates/host_env/src/io.rs b/crates/host_env/src/io.rs
@@ -252,3 +252,13 @@ pub fn write_once(fd: crt_fd::Borrowed<'_>, buf: &[u8]) -> io::Result<usize> {
 pub fn close_owned_fd(fd: crt_fd::Owned) -> io::Result<()> {
     crt_fd::close(fd)
 }
+
+/// Async-signal-safe raw write to the platform stderr file descriptor.
+/// Avoids `std::io::stderr()` locking so it is safe to call from fork
+/// children and signal handlers.
+#[cfg(unix)]
+pub fn write_stderr_raw(buf: &[u8]) {
+    unsafe {
+        let _ = libc::write(libc::STDERR_FILENO, buf.as_ptr().cast(), buf.len());
+    }
+}
diff --git a/crates/host_env/src/io_unsupported.rs b/crates/host_env/src/io_unsupported.rs
@@ -17,7 +17,7 @@ const O_TRUNC: i32 = 0x0400;
 const O_EXCL: i32 = 0x0800;
 
 bitflags::bitflags! {
-    #[derive(Copy, Clone, Debug, PartialEq)]
+    #[derive(Copy, Clone, Debug, PartialEq, Eq)]
     pub struct FileMode: u8 {
         const CREATED   = 0b0001;
         const READABLE  = 0b0010;

diff --git a/crates/host_env/src/lib.rs b/crates/host_env/src/lib.rs
@@ -83,4 +83,6 @@ pub mod winapi;
 #[cfg(windows)]
 pub mod winreg;
 #[cfg(windows)]
+pub mod winsound;
+#[cfg(windows)]
 pub mod wmi;
diff --git a/crates/host_env/src/mmap.rs b/crates/host_env/src/mmap.rs
@@ -5,10 +5,14 @@
 
 use std::io;
 
+#[cfg(windows)]
+use crate::windows::{CheckWin32Bool, HandleToOwned};
 #[cfg(unix)]
 use crate::{crt_fd, fileutils, posix};
 use memmap2::{Mmap, MmapMut, MmapOptions};
 #[cfg(windows)]
+use std::os::windows::io::{AsRawHandle, IntoRawHandle};
+#[cfg(windows)]
 use windows_sys::Win32::{
     Foundation::{
         CloseHandle, DUPLICATE_SAME_ACCESS, DuplicateHandle, GetLastError, HANDLE,
@@ -131,7 +135,7 @@ impl Drop for NamedMmap {
 #[cfg(windows)]
 pub fn duplicate_handle(handle: Handle) -> io::Result<Handle> {
     let mut new_handle: Handle = INVALID_HANDLE;
-    let result = unsafe {
+    unsafe {
         DuplicateHandle(
             GetCurrentProcess(),
             handle,
@@ -141,12 +145,9 @@ pub fn duplicate_handle(handle: Handle) -> io::Result<Handle> {
             0,
             DUPLICATE_SAME_ACCESS,
         )
-    };
-    if result == 0 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(new_handle)
     }
+    .check_win32_bool()?;
+    Ok(new_handle)
 }
 
 #[cfg(windows)]
@@ -187,13 +188,9 @@ pub fn is_invalid_handle_value(handle: isize) -> bool {
 
 #[cfg(windows)]
 pub fn extend_file(handle: Handle, size: i64) -> io::Result<()> {
-    if unsafe { SetFilePointerEx(handle, size, core::ptr::null_mut(), FILE_BEGIN) } == 0 {
-        return Err(io::Error::last_os_error());
-    }
-    if unsafe { SetEndOfFile(handle) } == 0 {
-        return Err(io::Error::last_os_error());
-    }
-    Ok(())
+    unsafe { SetFilePointerEx(handle, size, core::ptr::null_mut(), FILE_BEGIN) }
+        .check_win32_bool()?;
+    unsafe { SetEndOfFile(handle) }.check_win32_bool()
 }
 
 #[cfg(unix)]
@@ -210,11 +207,7 @@ pub fn close_handle(handle: Handle) {
 
 #[cfg(windows)]
 pub fn flush_view(ptr: *const core::ffi::c_void, size: usize) -> io::Result<()> {
-    if unsafe { FlushViewOfFile(ptr, size) } == 0 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(())
-    }
+    unsafe { FlushViewOfFile(ptr, size) }.check_win32_bool()
 }
 
 #[cfg(windows)]
@@ -252,21 +245,28 @@ pub fn create_named_mapping(
             size_lo,
             tag_wide.as_ptr(),
         )
-    };
-    if map_handle.is_null() {
-        return Err(io::Error::last_os_error());
     }
+    .into_owned()
+    .ok_or_else(io::Error::last_os_error)?;
 
     let off_hi = (offset as u64 >> 32) as u32;
     let off_lo = offset as u32;
-    let view = unsafe { MapViewOfFile(map_handle, desired_access, off_hi, off_lo, map_size) };
+    let view = unsafe {
+        MapViewOfFile(
+            map_handle.as_raw_handle() as Handle,
+            desired_access,
+            off_hi,
+            off_lo,
+            map_size,
+        )
+    };
     if view.Value.is_null() {
-        unsafe { CloseHandle(map_handle) };
+        // `map_handle` is closed automatically when dropped on this error path.
         return Err(io::Error::last_os_error());
     }
 
     Ok(NamedMmap {
-        map_handle,
+        map_handle: map_handle.into_raw_handle() as Handle,
         view_ptr: view.Value as *mut u8,
         len: map_size,
     })

diff --git a/crates/host_env/src/msvcrt.rs b/crates/host_env/src/msvcrt.rs
@@ -2,6 +2,7 @@ use alloc::{string::String, vec::Vec};
 use std::io;
 
 use crate::crt_fd;
+use crate::os::CheckLibcResult;
 use windows_sys::Win32::System::Diagnostics::Debug;
 
 pub type ErrorMode = u32;
@@ -89,39 +90,21 @@ pub fn kbhit() -> i32 {
 }
 
 pub fn locking(fd: i32, mode: i32, nbytes: i64) -> io::Result<()> {
-    let ret = unsafe { suppress_iph!(_locking(fd, mode, nbytes)) };
-    if ret == -1 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(())
-    }
+    unsafe { suppress_iph!(_locking(fd, mode, nbytes)) }.check_libc_neg()?;
+    Ok(())
 }
 
 pub fn heapmin() -> io::Result<()> {
-    let ret = unsafe { suppress_iph!(_heapmin()) };
-    if ret == -1 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(())
-    }
+    unsafe { suppress_iph!(_heapmin()) }.check_libc_neg()?;
+    Ok(())
 }
 
 pub fn setmode(fd: crt_fd::Borrowed<'_>, flags: i32) -> io::Result<i32> {
-    let ret = unsafe { suppress_iph!(_setmode(fd, flags)) };
-    if ret == -1 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(ret)
-    }
+    unsafe { suppress_iph!(_setmode(fd, flags)) }.check_libc_neg()
 }
 
 pub fn open_osfhandle(handle: isize, flags: i32) -> io::Result<i32> {
-    let ret = unsafe { suppress_iph!(libc::open_osfhandle(handle, flags)) };
-    if ret == -1 {
-        Err(io::Error::last_os_error())
-    } else {
-        Ok(ret)
-    }
+    unsafe { suppress_iph!(libc::open_osfhandle(handle, flags)) }.check_libc_neg()
 }
 
 pub fn get_error_mode() -> u32 {

diff --git a/crates/host_env/src/multiprocessing.rs b/crates/host_env/src/multiprocessing.rs
@@ -159,13 +159,11 @@ impl SemHandle {
 #[cfg(windows)]
 impl SemHandle {
     pub fn create(value: i32, maxvalue: i32) -> io::Result<Self> {
+        use crate::windows::CheckWin32Handle;
         let handle =
-            unsafe { CreateSemaphoreW(core::ptr::null(), value, maxvalue, core::ptr::null()) };
-        if handle == 0 as HANDLE {
-            Err(io::Error::last_os_error())
-        } else {
-            Ok(Self { raw: handle })
-        }
+            unsafe { CreateSemaphoreW(core::ptr::null(), value, maxvalue, core::ptr::null()) }
+                .check_nonnull()?;
+        Ok(Self { raw: handle })
     }
 
     #[inline]