youknowone · Nov 7, 2026 · Nov 3, 2026 · Nov 3, 2026 · Nov 3, 2026 · Nov 3, 2026
diff --git a/Lib/test/test_audit.py b/Lib/test/test_audit.py
@@ -233,7 +233,7 @@ def test_threading(self):
         self.assertEqual(actual, expected)
 
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
+    @unittest.expectedFailureIf(sys.platform != "win32", "TODO: RUSTPYTHON")
     def test_wmi_exec_query(self):
         import_helper.import_module("_wmi")
         returncode, events, stderr = self.run_python("test_wmi_exec_query")

diff --git a/crates/host_env/src/testconsole.rs b/crates/host_env/src/testconsole.rs
@@ -4,12 +4,17 @@ use windows_sys::Win32::{
     System::Console::{INPUT_RECORD, KEY_EVENT, WriteConsoleInputW},
 };
 
-use crate::windows::{CheckWin32Bool, CheckWin32Handle};
+use crate::windows::CheckWin32Bool;
 
-pub fn write_console_input(fd: i32, data: &[u16]) -> io::Result<()> {
-    let handle = (unsafe { libc::get_osfhandle(fd) } as HANDLE).check_valid()?;
+fn console_handle(fd: i32) -> io::Result<HANDLE> {
+    let raw_handle = unsafe { crate::suppress_iph!(libc::get_osfhandle(fd)) };
+    if raw_handle == -1 {
+        return Err(crate::os::errno_io_error());
+    }
+    Ok(raw_handle as HANDLE)
+}
 
-    let size = data.len() as u32;
+fn input_records(data: &[u16]) -> Vec<INPUT_RECORD> {
     let mut records: Vec<INPUT_RECORD> = Vec::with_capacity(data.len());
     for &wc in data {
         let mut rec: INPUT_RECORD = unsafe { core::mem::zeroed() };
@@ -19,7 +24,11 @@ pub fn write_console_input(fd: i32, data: &[u16]) -> io::Result<()> {
         rec.Event.KeyEvent.uChar.UnicodeChar = wc;
         records.push(rec);
     }
+    records
+}
 
+fn write_records(handle: HANDLE, records: &[INPUT_RECORD]) -> io::Result<()> {
+    let size = records.len() as u32;
     let mut total: u32 = 0;
     while total < size {
         let mut wrote: u32 = 0;
@@ -40,6 +49,19 @@ pub fn write_console_input(fd: i32, data: &[u16]) -> io::Result<()> {
         }
         total += wrote;
     }
-
     Ok(())
 }
+
+pub fn write_console_input(fd: i32, data: &[u16]) -> io::Result<()> {
+    let handle = console_handle(fd)?;
+    let records = input_records(data);
+    write_records(handle, &records)
+}
+
+/// Resolve the descriptor after preparing the input records.
+#[doc(hidden)]
+pub fn write_console_input_with_fd(data: &[u16], get_fd: impl FnOnce() -> i32) -> io::Result<()> {
+    let records = input_records(data);
+    let handle = console_handle(get_fd())?;
+    write_records(handle, &records)
+}
diff --git a/crates/stdlib/src/_testconsole.rs b/crates/stdlib/src/_testconsole.rs
@@ -3,32 +3,58 @@ pub(crate) use _testconsole::module_def;
 #[pymodule]
 mod _testconsole {
     use crate::vm::{
-        PyObjectRef, PyResult, VirtualMachine, convert::IntoPyException, function::ArgBytesLike,
+        AsObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine, builtins::PyTypeRef,
+        convert::IntoPyException, function::ArgBytesLike,
     };
     use rustpython_host_env::testconsole as host_testconsole;
 
-    #[pyfunction]
-    fn write_input(file: PyObjectRef, s: ArgBytesLike, vm: &VirtualMachine) -> PyResult<()> {
-        // Get the fd from the file object via fileno()
-        let fd_obj = vm.call_method(&file, "fileno", ())?;
-        let fd: i32 = fd_obj.try_into_value(vm)?;
-
-        let data = s.borrow_buf();
-        let data = &*data;
+    #[derive(FromArgs)]
+    struct WriteInputArgs {
+        #[pyarg(any)]
+        file: PyObjectRef,
+        #[pyarg(any)]
+        s: ArgBytesLike,
+    }
 
-        // Interpret as UTF-16-LE pairs
-        let (chunks, []) = data.as_chunks::<2>() else {
-            return Err(vm.new_value_error("buffer must contain UTF-16-LE data (even length)"));
+    #[pyfunction]
+    fn write_input(args: WriteInputArgs, vm: &VirtualMachine) -> PyResult<()> {
+        let s = args.s;
+        let console_type = {
+            let io = vm.import("_io", 0)?;
+            PyTypeRef::try_from_object(vm, io.get_attr("_WindowsConsoleIO", vm)?)?
         };
-        let wchars: Vec<u16> = chunks
-            .iter()
-            .map(|chunk| u16::from_le_bytes([chunk[0], chunk[1]]))
-            .collect();
-        host_testconsole::write_console_input(fd, &wchars).map_err(|e| e.into_pyexception(vm))
+        let is_console = args.file.fast_isinstance(&console_type);
+        drop(console_type);
+        if !is_console || crate::vm::stdlib::_io::raw_windows_console_fd(&args.file).is_none() {
+            return Err(vm.new_type_error("expected raw console object"));
+        }
+        // CPython interprets complete UTF-16-LE pairs and ignores a final byte.
+        // Release the buffer borrow before the OS call and error conversion.
+        let wchars: Vec<u16> = {
+            let data = s.borrow_buf();
+            let (chunks, _) = data.as_chunks::<2>();
+            // CPython's Windows implementation casts the byte length to DWORD first.
+            let count = (data.len() as u32 / 2) as usize;
+            chunks[..count]
+                .iter()
+                .map(|chunk| u16::from_le_bytes(*chunk))
+                .collect()
+        };
+        host_testconsole::write_console_input_with_fd(&wchars, || {
+            crate::vm::stdlib::_io::raw_windows_console_fd(&args.file).unwrap_or(-1)
+        })
+        .map_err(|e| e.into_pyexception(vm))
+    }
+
+    #[derive(FromArgs)]
+    struct ReadOutputArgs {
+        #[pyarg(any)]
+        file: PyObjectRef,
     }
 
     #[pyfunction]
-    fn read_output(_file: PyObjectRef) -> Option<()> {
+    fn read_output(args: ReadOutputArgs) -> Option<()> {
+        let _file = args.file;
         // Stub, same as CPython
         None
     }

diff --git a/crates/vm/src/stdlib/_io.rs b/crates/vm/src/stdlib/_io.rs
@@ -52,6 +52,13 @@ fn open_file_descriptor(name: &PyObject, vm: &VirtualMachine) -> PyResult<Option
     Ok(fd)
 }
 
+/// Return a non-owning descriptor snapshot of a native Windows console stream.
+#[doc(hidden)]
+#[cfg(all(feature = "host_env", windows))]
+pub fn raw_windows_console_fd(obj: &PyObject) -> Option<i32> {
+    winconsoleio::raw_console_fd(obj)
+}
+
 fn file_closed(file: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
     file.get_attr("closed", vm)?.try_to_bool(vm)
 }
@@ -6672,6 +6679,11 @@ mod winconsoleio {
     const SMALLBUF: usize = 4;
     const BUFMAX: usize = 32 * 1024 * 1024;
 
+    pub(super) fn raw_console_fd(obj: &PyObject) -> Option<i32> {
+        obj.downcast_ref::<WindowsConsoleIO>()
+            .map(|stream| stream.fd.load())
+    }
+
     fn handle_from_fd(fd: i32) -> HANDLE {
         host_nt::handle_from_fd(fd)
     }

diff --git a/crates/vm/src/stdlib/_winapi.rs b/crates/vm/src/stdlib/_winapi.rs
@@ -796,8 +796,15 @@ mod _winapi {
         vm.ctx.new_str(result_str)
     }
 
+    #[derive(FromArgs)]
+    struct PathNameArgs {
+        #[pyarg(any)]
+        path: PyStrRef,
+    }
+
     #[pyfunction]
-    fn GetShortPathName(path: PyStrRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+    fn GetShortPathName(args: PathNameArgs, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        let path = args.path;
         let path = path
             .as_wtf8()
             .to_wide_cstring()
@@ -807,7 +814,8 @@ mod _winapi {
     }
 
     #[pyfunction]
-    fn GetLongPathName(path: PyStrRef, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+    fn GetLongPathName(args: PathNameArgs, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        let path = args.path;
         let path = path
             .as_wtf8()
             .to_wide_cstring()
@@ -1246,11 +1254,18 @@ mod _winapi {
         host_winapi::copy_file2(&src_wide, &dst_wide, args.flags).map_err(|e| e.to_pyexception(vm))
     }
 
+    #[derive(FromArgs)]
+    struct MimeRegistryArgs {
+        #[pyarg(any)]
+        on_type_read: PyObjectRef,
+    }
+
     #[pyfunction]
     fn _mimetypes_read_windows_registry(
-        on_type_read: PyObjectRef,
+        args: MimeRegistryArgs,
         vm: &VirtualMachine,
     ) -> PyResult<()> {
+        let on_type_read = args.on_type_read;
         host_winapi::read_windows_mimetype_registry_in_batches(|entries| {
             for (mime_type, ext) in entries.drain(..) {
                 on_type_read.call((vm.ctx.new_str(mime_type), vm.ctx.new_str(ext)), vm)?;

diff --git a/crates/vm/src/stdlib/_wmi.rs b/crates/vm/src/stdlib/_wmi.rs
@@ -10,17 +10,35 @@ mod _wmi {
     use crate::{PyResult, VirtualMachine};
     use rustpython_host_env::wmi as host_wmi;
 
-    #[pyfunction]
-    fn exec_query(query: PyStrRef, vm: &VirtualMachine) -> PyResult<String> {
-        let query_str = query.expect_str();
+    #[derive(FromArgs)]
+    struct ExecQueryArgs {
+        #[pyarg(any)]
+        query: PyStrRef,
+    }
 
-        if !query_str
+    #[pyfunction]
+    fn exec_query(args: ExecQueryArgs, vm: &VirtualMachine) -> PyResult<PyStrRef> {
+        // Bind all keywords before converting the query, as Argument Clinic does.
+        let query = args.query;
+        vm.audit("_wmi.exec_query", || (query.clone(),))?;
+        let mut code_units = query.as_wtf8().encode_wide().collect::<Vec<_>>();
+        // Adding the terminator first makes even a trailing input NUL interior.
+        code_units.push(0);
+        let wide = widestring::WideCString::from_vec(code_units)
+            .map_err(|_| vm.new_value_error("embedded null character"))?;
+        if !query
+            .as_wtf8()
+            .as_bytes()
             .get(..7)
-            .is_some_and(|s| s.eq_ignore_ascii_case("select "))
+            .is_some_and(|s| s.eq_ignore_ascii_case(b"select "))
         {
             return Err(vm.new_value_error("only SELECT queries are supported"));
         }
-
-        host_wmi::exec_query(query_str).map_err(|err| err.to_pyexception(vm))
+        host_wmi::exec_query_wide(&wide)
+            .map(|result| {
+                vm.ctx
+                    .new_str(crate::common::wtf8::Wtf8Buf::from_wide(&result))
+            })
+            .map_err(|err| err.to_pyexception(vm))
     }
 }
diff --git a/crates/vm/src/stdlib/nt.rs b/crates/vm/src/stdlib/nt.rs
@@ -241,6 +241,12 @@ pub(crate) mod module {
         path: crate::PyObjectRef,
     }
 
+    #[derive(FromArgs)]
+    struct OsPathArg {
+        #[pyarg(any)]
+        path: OsPath,
+    }
+
     impl PathArg {
         fn to_path_or_fd(&self, vm: &VirtualMachine) -> PyResult<Option<OsPathOrFd<'static>>> {
             match PathConverter::new().try_path_or_fd_allow_invalid(self.path.clone(), vm) {
@@ -378,7 +384,8 @@ pub(crate) mod module {
     }
 
     #[pyfunction]
-    fn _path_isdevdrive(path: OsPath, vm: &VirtualMachine) -> PyResult<bool> {
+    fn _path_isdevdrive(args: OsPathArg, vm: &VirtualMachine) -> PyResult<bool> {
+        let path = args.path;
         let path = path.to_wide_cstring(vm)?;
         host_nt::path_isdevdrive(&path).map_err(|err| err.to_pyexception(vm))
     }
@@ -615,7 +622,8 @@ pub(crate) mod module {
     }
 
     #[pyfunction]
-    fn _getvolumepathname(path: OsPath, vm: &VirtualMachine) -> PyResult {
+    fn _getvolumepathname(args: OsPathArg, vm: &VirtualMachine) -> PyResult {
+        let path = args.path;
         let wide = path.to_wide_cstring(vm)?;
         let buflen = core::cmp::max(wide.len(), host_nt::MAX_PATH_USIZE);
         if buflen > u32::MAX as usize {
@@ -915,13 +923,17 @@ pub(crate) mod module {
     }
 
     #[pyfunction]
-    fn _path_normpath(path: crate::PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        // Handle path-like objects via os.fspath
-        let path = if let Some(fspath) = vm.get_method(path.clone(), identifier!(vm, __fspath__)) {
-            fspath?.call((), vm)?
-        } else {
-            path
-        };
+    fn _path_normpath(args: PathArg, vm: &VirtualMachine) -> PyResult {
+        let path = args.path;
+        // Direct strings and bytes take precedence over __fspath__, including subclasses.
+        let path =
+            if path.downcast_ref::<PyStr>().is_some() || path.downcast_ref::<PyBytes>().is_some() {
+                path
+            } else if let Some(fspath) = vm.get_method(path.clone(), identifier!(vm, __fspath__)) {
+                fspath?.call((), vm)?
+            } else {
+                path
+            };
 
         let (wide, is_bytes): (Vec<u16>, bool) = if let Some(s) = path.downcast_ref::<PyStr>() {
             let wide: Vec<u16> = s.as_wtf8().encode_wide().collect();
@@ -949,7 +961,8 @@ pub(crate) mod module {
     }
 
     #[pyfunction]
-    fn _getdiskusage(path: OsPath, vm: &VirtualMachine) -> PyResult<(u64, u64)> {
+    fn _getdiskusage(args: OsPathArg, vm: &VirtualMachine) -> PyResult<(u64, u64)> {
+        let path = args.path;
         let path = path.to_wide_cstring(vm)?;
         host_nt::getdiskusage(&path).map_err(|err| err.to_pyexception(vm))
     }
@@ -995,8 +1008,15 @@ pub(crate) mod module {
         Ok(vm.ctx.new_list(result))
     }
 
+    #[derive(FromArgs)]
+    struct VolumeArg {
+        #[pyarg(any)]
+        volume: OsPath,
+    }
+
     #[pyfunction]
-    fn listmounts(volume: OsPath, vm: &VirtualMachine) -> PyResult<PyListRef> {
+    fn listmounts(args: VolumeArg, vm: &VirtualMachine) -> PyResult<PyListRef> {
+        let volume = args.volume;
         let volume = volume.to_wide_cstring(vm)?;
         let result = host_nt::listmounts(&volume)
             .map_err(|err| err.to_pyexception(vm))?
@@ -1108,7 +1128,8 @@ pub(crate) mod module {
     }
 
     #[pyfunction]
-    fn _add_dll_directory(path: OsPath, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+    fn _add_dll_directory(args: OsPathArg, vm: &VirtualMachine) -> PyResult<PyObjectRef> {
+        let path = args.path;
         let wide = path.to_wide_cstring(vm)?;
         let cookie = host_winapi::add_dll_directory(&wide)
             .map_err(|err| OSErrorBuilder::with_filename(&err, path, vm))?;
@@ -1118,8 +1139,15 @@ pub(crate) mod module {
             .into())
     }
 
+    #[derive(FromArgs)]
+    struct DllDirectoryCookieArg {
+        #[pyarg(any)]
+        cookie: PyObjectRef,
+    }
+
     #[pyfunction]
-    fn _remove_dll_directory(cookie: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
+    fn _remove_dll_directory(args: DllDirectoryCookieArg, vm: &VirtualMachine) -> PyResult<()> {
+        let cookie = args.cookie;
         let not_a_cookie =
             || vm.new_type_error("Provided cookie was not returned from os.add_dll_directory");
         let capsule = cookie