youknowone · Nov 6, 2026 · Nov 3, 2026 · Nov 3, 2026 · Nov 3, 2026 · Nov 4, 2026
diff --git a/crates/vm/src/ospath.rs b/crates/vm/src/ospath.rs
@@ -91,6 +91,16 @@ impl PathConverter {
             Err(obj) => obj,
         };
 
+        self.try_pathlike(obj, allow_fd, vm)
+    }
+
+    /// Convert an object already known not to be a str or bytes.
+    pub(crate) fn try_pathlike(
+        &self,
+        obj: PyObjectRef,
+        allow_fd: bool,
+        vm: &VirtualMachine,
+    ) -> PyResult<OsPath> {
         // Call __fspath__
         let type_error_msg = || self.type_error_msg(&obj.class().name(), allow_fd);
         let method =
@@ -112,7 +122,7 @@ impl PathConverter {
     }
 
     /// Try to match str or bytes, returns Err(obj) if neither
-    fn try_match_str_bytes(
+    pub(crate) fn try_match_str_bytes(
         &self,
         obj: PyObjectRef,
         vm: &VirtualMachine,

diff --git a/crates/vm/src/ospath_fd.rs b/crates/vm/src/ospath_fd.rs
@@ -9,14 +9,32 @@ use crate::{
 use rustpython_host_env::crt_fd;
 
 impl PathConverter {
-    /// Convert to a path or a file descriptor. Integers are treated as fds
-    /// before `__fspath__` is considered.
+    /// Convert str and bytes to paths first, then treat indexable objects as
+    /// file descriptors before considering `__fspath__`.
     pub(crate) fn try_path_or_fd<'fd>(
         &self,
         obj: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<OsPathOrFd<'fd>> {
-        if let Some(int) = obj.try_index_opt(vm) {
+        let obj = match self.try_match_str_bytes(obj, vm)? {
+            Ok(path) => return Ok(OsPathOrFd::Path(path)),
+            Err(obj) => obj,
+        };
+
+        if let Some(fd) = self.try_index_as_fd(&obj, vm) {
+            return fd;
+        }
+
+        self.try_pathlike(obj, true, vm).map(OsPathOrFd::Path)
+    }
+
+    fn try_index_as_fd<'fd>(
+        &self,
+        obj: &PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> Option<PyResult<OsPathOrFd<'fd>>> {
+        let int = obj.try_index_opt(vm)?;
+        Some((|| {
             if obj
                 .class()
                 .is(crate::builtins::bool_::PyBool::static_type())
@@ -29,12 +47,10 @@ impl PathConverter {
                 )?;
             }
             let fd = int?.try_to_primitive(vm)?;
-            return unsafe { crt_fd::Borrowed::try_borrow_raw(fd) }
+            unsafe { crt_fd::Borrowed::try_borrow_raw(fd) }
                 .map(OsPathOrFd::Fd)
-                .map_err(|e| e.into_pyexception(vm));
-        }
-
-        self.try_path_inner(obj, true, vm).map(OsPathOrFd::Path)
+                .map_err(|e| e.into_pyexception(vm))
+        })())
     }
 }
 

diff --git a/crates/vm/src/stdlib/_io.rs b/crates/vm/src/stdlib/_io.rs
@@ -26,6 +26,32 @@ use crate::{
 pub use _io::{OpenArgs, io_open as open};
 use rustpython_host_env::io as host_io;
 
+/// Mirror the file descriptor conversion used by FileIO and WindowsConsoleIO.
+#[cfg(feature = "host_env")]
+fn open_file_descriptor(name: &PyObject, vm: &VirtualMachine) -> PyResult<Option<i32>> {
+    if name.class().is(vm.ctx.types.bool_type) {
+        crate::stdlib::_warnings::warn(
+            vm.ctx.exceptions.runtime_warning,
+            "bool is used as a file descriptor".to_owned(),
+            1,
+            vm,
+        )?;
+    }
+    // CPython clears failed integer conversions and then tries a path. Do not
+    // turn a failed conversion into a negative descriptor error.
+    let fd = if let Some(i) = name.downcast_ref::<crate::builtins::PyInt>() {
+        i.try_to_primitive::<i32>(vm).ok()
+    } else {
+        name.try_index_opt(vm)
+            .and_then(Result::ok)
+            .and_then(|i| i.try_to_primitive::<i32>(vm).ok())
+    };
+    if fd.is_some_and(|fd| fd < 0) {
+        return Err(vm.new_value_error("negative file descriptor"));
+    }
+    Ok(fd)
+}
+
 fn file_closed(file: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
     file.get_attr("closed", vm)?.try_to_bool(vm)
 }
@@ -5789,6 +5815,15 @@ mod _io {
         opts: OpenArgs,
         vm: &VirtualMachine,
     ) -> PyResult {
+        // Match _io.open: numeric objects go to FileIO unchanged; other
+        // arguments are resolved through the path protocol before mode parsing.
+        let file = if crate::protocol::PyNumber::check(&file) {
+            file
+        } else {
+            // Keep the original argument alive through opening and wrapper setup.
+            FsPath::try_from_path_like(file.as_object().to_owned(), false, vm)?.to_pyobject(vm)
+        };
+
         // mode is optional: 'rt' is the default mode (open from reading text)
         let mode_string = mode.unwrap_or("r");
         let mode = mode_string
@@ -5810,22 +5845,6 @@ mod _io {
             }
         }
 
-        // Match CPython's _pyio.open (Lib/_pyio.py): resolve PathLike here so
-        // _io.FileIO still receives (and preserves on .name) the raw argument
-        // when called directly.
-        let file = if file.fast_isinstance(vm.ctx.types.int_type) {
-            file
-        } else {
-            FsPath::try_from_path_like(file, true, vm)?.to_pyobject(vm)
-        };
-
-        // check file descriptor validity
-        #[cfg(all(unix, feature = "host_env"))]
-        if let Ok(crate::ospath::OsPathOrFd::Fd(fd)) = file.clone().try_into_value(vm) {
-            rustpython_host_env::fcntl::validate_fd(fd.as_raw())
-                .map_err(|_| vm.new_last_errno_error())?;
-        }
-
         // Construct a RawIO (subclass of RawIOBase)
         // On Windows, use _WindowsConsoleIO for console handles.
         // This is subsequently consumed by a Buffered Class.
@@ -6103,7 +6122,7 @@ mod fileio {
         builtins::{PyBaseExceptionRef, PyUtf8Str, PyUtf8StrRef},
         common::wtf8::Wtf8Buf,
         convert::{IntoPyException, ToPyException},
-        exceptions::OSErrorBuilder,
+        exceptions::{OSErrorBuilder, ToOSErrorBuilder},
         function::{ArgBytesLike, ArgMemoryBuffer},
         ospath::{OsPath, OsPathOrFd},
         stdlib::os,
@@ -6160,21 +6179,10 @@ mod fileio {
         fn init(zelf: &Py<Self>, args: Self::Args, vm: &VirtualMachine) -> PyResult<()> {
             // TODO: let atomic_flag_works
             let name = args.file;
-            // Check if bool is used as file descriptor
-            if name.class().is(vm.ctx.types.bool_type) {
-                crate::stdlib::_warnings::warn(
-                    vm.ctx.exceptions.runtime_warning,
-                    "bool is used as a file descriptor".to_owned(),
-                    1,
-                    vm,
-                )?;
-            }
-            let arg_fd = if let Some(i) = name.downcast_ref::<crate::builtins::PyInt>() {
-                let fd = i.try_to_primitive(vm)?;
-                if fd < 0 {
-                    return Err(vm.new_value_error("negative file descriptor"));
-                }
-                Some(fd)
+            let arg_fd = super::open_file_descriptor(&name, vm)?;
+            // Resolve the path before mode validation, even with a custom opener.
+            let mut path = if arg_fd.is_none() {
+                Some(OsPath::try_from_fspath(name.clone(), vm)?)
             } else {
                 None
             };
@@ -6189,7 +6197,7 @@ mod fileio {
             let flags = parsed.flags;
             zelf.mode.store(mode);
 
-            let (fd, filename) = if let Some(fd) = arg_fd {
+            let (fd, _filename) = if let Some(fd) = arg_fd {
                 zelf.closefd.store(args.closefd);
                 (fd, None)
             } else {
@@ -6209,7 +6217,7 @@ mod fileio {
                     }
                     (fd, None)
                 } else {
-                    let path = OsPath::try_from_fspath(name.clone(), vm)?;
+                    let path = path.take().expect("a filename was resolved above");
                     #[cfg(any(unix, target_os = "wasi"))]
                     let raw_path = path.clone().into_cstring(vm)?;
                     #[cfg(windows)]
@@ -6231,8 +6239,6 @@ mod fileio {
             let fd_is_own = arg_fd.is_none();
             zelf.fd.store(fd);
             let fd = unsafe { crt_fd::Borrowed::borrow_raw(fd) };
-            let filename = filename.unwrap_or(OsPathOrFd::Fd(fd));
-
             // TODO: _Py_set_inheritable
 
             match host_io::inspect_file_target(fd) {
@@ -6245,7 +6251,14 @@ mod fileio {
                     if host_io::should_forget_fd_after_inspect_error(&err, fd_is_own) {
                         zelf.fd.store(-1);
                     }
-                    return Err(OSErrorBuilder::with_filename(&err, filename, vm));
+                    if err.posix_errno() == libc::EBADF {
+                        return Err(err.to_pyexception(vm));
+                    }
+                    // Keep the original name alive through error construction and local cleanup.
+                    return Err(err
+                        .to_os_error_builder(vm)
+                        .filename(name.as_object().to_owned())
+                        .into_pyexception(vm));
                 }
             }
 
@@ -6644,7 +6657,7 @@ mod winconsoleio {
         common::{lock::PyMutex, wtf8::Wtf8Buf},
         convert::{IntoPyException, ToPyException},
         exceptions::nul_char_error,
-        function::{ArgBytesLike, ArgMemoryBuffer, OptionalArg},
+        function::{ArgBytesLike, ArgMemoryBuffer, FsPath, OptionalArg},
         types::{Constructor, DefaultConstructor, Destructor, Initializer, Representable},
     };
     use crossbeam_utils::atomic::AtomicCell;
@@ -6668,14 +6681,25 @@ mod winconsoleio {
     /// Returns 'r' (input), 'w' (output), 'x' (generic CON), or '\0' (not a console).
     pub(super) fn pyio_get_console_type(path_or_fd: &PyObject, vm: &VirtualMachine) -> char {
         // Try as integer fd first
-        if let Ok(fd) = i32::try_from_object(vm, path_or_fd.to_owned()) {
+        if let Ok(fd) = i32::try_from_object(vm, path_or_fd.to_owned())
+            && fd >= 0
+        {
             return host_nt::console_type_from_fd(fd);
         }
 
         // Try as string path
-        let Ok(name) = path_or_fd.str(vm) else {
+        let Ok(path) = FsPath::try_from_path_like(path_or_fd.to_owned(), true, vm) else {
             return '\0';
         };
+        let name = match &path {
+            FsPath::Str(name) => name.to_owned(),
+            FsPath::Bytes(_) => {
+                let Ok(path) = path.as_os_str(vm) else {
+                    return '\0';
+                };
+                vm.fsdecode(path.into_owned())
+            }
+        };
         let Some(name_str) = name.to_str() else {
             // Surrogate strings can't be console device names
             return '\0';
@@ -6754,24 +6778,22 @@ mod winconsoleio {
                 }
             }
 
-            // Warn if bool is used as file descriptor
-            if nameobj.class().is(vm.ctx.types.bool_type) {
-                crate::stdlib::_warnings::warn(
-                    vm.ctx.exceptions.runtime_warning,
-                    "bool is used as a file descriptor".to_owned(),
-                    1,
-                    vm,
-                )?;
-            }
-
-            // Try to get fd from integer
-            let mut fd: i32 = -1;
-            if let Some(i) = nameobj.downcast_ref::<crate::builtins::PyInt>() {
-                fd = i.try_to_primitive::<i32>(vm).unwrap_or(-1);
-                if fd < 0 {
-                    return Err(vm.new_value_error("negative file descriptor"));
-                }
-            }
+            let mut fd = super::open_file_descriptor(&nameobj, vm)?.unwrap_or(-1);
+            let path = if fd < 0 {
+                let path = FsPath::try_from_path_like(nameobj.clone(), true, vm)?;
+                let decoded = match &path {
+                    FsPath::Str(s) => s.to_owned(),
+                    FsPath::Bytes(_) => vm.fsdecode(path.as_os_str(vm)?.into_owned()),
+                };
+                let wide = decoded
+                    .as_wtf8()
+                    .to_wide_cstring()
+                    .map_err(|e| e.to_pyexception(vm))?;
+                let console_type = pyio_get_console_type(decoded.as_object(), vm);
+                Some((wide, console_type))
+            } else {
+                None
+            };
 
             // Parse mode
             let mut rwa = false;
@@ -6812,8 +6834,9 @@ mod winconsoleio {
             zelf.writable.store(writable);
 
             if fd < 0 {
-                // Get console type from name
-                console_type = pyio_get_console_type(&nameobj, vm);
+                // The decoded name was resolved before mode validation.
+                let (wide, detected_type) = path.expect("a filename was resolved above");
+                console_type = detected_type;
                 if console_type == 'x' {
                     if writable {
                         console_type = 'w';
@@ -6828,12 +6851,6 @@ mod winconsoleio {
                     return Err(vm.new_value_error("Cannot use closefd=False with file name"));
                 }
 
-                let name_str = nameobj.str(vm)?;
-                let wide = name_str
-                    .as_wtf8()
-                    .to_wide_cstring()
-                    .map_err(|e| e.to_pyexception(vm))?;
-
                 fd = host_nt::open_console_path_fd(&wide, writable)
                     .map_err(|err| err.to_pyexception(vm))?;
             } else {