youknowone · Oct 29, 2026 · Oct 27, 2026 · coderabbitai · Oct 28, 2026 · chatgpt-codex-connector
diff --git a/Lib/test/test_zipfile/test_core.py b/Lib/test/test_zipfile/test_core.py
@@ -1460,7 +1460,6 @@ def requiresWriteAccess(self, path):
             self.skipTest('requires write access to the installed location')
         unlink(filename)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_write_pyfile(self):
         self.requiresWriteAccess(os.path.dirname(__file__))
         with TemporaryFile() as t, zipfile.PyZipFile(t, "w") as zipfp:
@@ -1491,7 +1490,6 @@ def test_write_pyfile(self):
             self.assertNotIn(bn, zipfp.namelist())
             self.assertCompiledIn(bn, zipfp.namelist())
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_write_python_package(self):
         import email
         packagedir = os.path.dirname(email.__file__)
@@ -1506,7 +1504,6 @@ def test_write_python_package(self):
             self.assertCompiledIn('email/__init__.py', names)
             self.assertCompiledIn('email/mime/text.py', names)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON; - AttributeError: module 'os' has no attribute 'supports_effective_ids'
     def test_write_filtered_python_package(self):
         import test
         packagedir = os.path.dirname(test.__file__)
@@ -1537,7 +1534,6 @@ def filter(path):
                 print(reportStr)
             self.assertTrue('SyntaxError' not in reportStr)
 
-    @unittest.expectedFailure  # TODO: RUSTPYTHON
     def test_write_with_optimization(self):
         import email
         packagedir = os.path.dirname(email.__file__)

diff --git a/crates/host_env/src/nt.rs b/crates/host_env/src/nt.rs
@@ -23,7 +23,7 @@ use crate::{
 };
 use libc::intptr_t;
 
-use widestring::WideCString;
+use widestring::{WideCStr, WideCString};
 use windows_sys::{
     Win32::{
         Foundation::{
@@ -265,11 +265,8 @@ pub enum ReadConsoleError {
     BufferTooSmall { available: usize, required: usize },
 }
 
-pub fn access(path: &Path, mode: u8) -> bool {
-    let Ok(wide) = WideCString::from_os_str(path.as_os_str()) else {
-        return false;
-    };
-    let attr = unsafe { GetFileAttributesW(wide.as_ptr()) };
+pub fn access(path: &WideCStr, mode: u8) -> bool {
+    let attr = unsafe { GetFileAttributesW(path.as_ptr()) };
     attr != INVALID_FILE_ATTRIBUTES
         && (mode & 2 == 0
             || attr & FILE_ATTRIBUTE_READONLY == 0

diff --git a/crates/host_env/src/posix.rs b/crates/host_env/src/posix.rs
@@ -954,18 +954,6 @@ pub struct Permissions {
     pub is_executable: bool,
 }
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum AccessError {
-    InvalidMode,
-    Os(i32),
-}
-
-impl From<std::io::Error> for AccessError {
-    fn from(value: std::io::Error) -> Self {
-        Self::Os(value.raw_os_error().unwrap_or(0))
-    }
-}
-
 pub use crate::os::{AccessMode, F_OK, R_OK, W_OK, X_OK};
 
 fn get_permissions(mode: u32) -> Permissions {
@@ -1031,7 +1019,14 @@ pub fn getgroups() -> std::io::Result<Vec<u32>> {
     Err(std::io::Error::from_raw_os_error(libc::EOPNOTSUPP))
 }
 
-pub fn check_access(path: &Path, mode: u8) -> Result<bool, AccessError> {
+#[cfg(any(target_os = "espidf", target_os = "horizon", target_os = "vita",))]
+pub fn check_access(
+    dir_fd: Option<crt_fd::Borrowed<'_>>,
+    path: &Path,
+    mode: u8,
+    effective_ids: bool,
+    follow_symlinks: bool,
+) -> Result<bool, AccessError> {
     use std::os::unix::fs::MetadataExt;
 
     let Some(mode) = AccessMode::from_bits(mode) else {

diff --git a/crates/host_env/src/posix_unix_like.rs b/crates/host_env/src/posix_unix_like.rs
@@ -4,13 +4,55 @@ use std::{io, path::Path};
 
 use rustix::{
     fd::AsFd,
-    fs::{self, AtFlags},
+    fs::{self, Access, AtFlags},
 };
 
 pub use rustix::fs::RawMode;
 
 use crate::{crt_fd, fileutils::StatStruct};
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum AccessError {
+    InvalidMode,
+    Os(i32),
+}
+
+impl From<io::Error> for AccessError {
+    fn from(value: io::Error) -> Self {
+        Self::Os(value.raw_os_error().unwrap_or(0))
+    }
+}
+
+/// https://www.man7.org/linux/man-pages/man2/faccessat.2.html
+#[cfg(not(any(target_os = "espidf", target_os = "horizon", target_os = "vita")))]
+pub fn check_access(
+    dir_fd: Option<crt_fd::Borrowed<'_>>,
+    path: impl AsRef<Path>,
+    access: u8,
+    #[cfg_attr(target_os = "android", expect(unused))] effective_ids: bool,
+    follow_symlinks: bool,
+) -> Result<bool, AccessError> {
+    let dir_fd = dir_fd.as_ref().map_or(fs::CWD, AsFd::as_fd);
+    let access = Access::from_bits(access as _).ok_or(AccessError::InvalidMode)?;
+
+    #[cfg(not(target_os = "android"))]
+    let flags = if effective_ids {
+        AtFlags::EACCESS
+    } else {
+        AtFlags::empty()
+    };
+    #[cfg(target_os = "android")]
+    let flags = AtFlags::empty();
+    let flags = flags.union(if !follow_symlinks {
+        AtFlags::SYMLINK_NOFOLLOW
+    } else {
+        AtFlags::empty()
+    });
+
+    // CPython returns false for all error codes.
+    Ok(fs::accessat(dir_fd, path.as_ref(), access, flags).is_ok())
+}
+
 /// https://pubs.opengroup.org/onlinepubs/9799919799/functions/mkdir.html
 pub fn make_dir(
     dir_fd: Option<crt_fd::Borrowed<'_>>,

diff --git a/crates/vm/src/stdlib/nt.rs b/crates/vm/src/stdlib/nt.rs
@@ -13,7 +13,7 @@ pub(crate) mod module {
         function::{ArgMapping, Either, FsPath, OptionalArg},
         host_env::crt_fd,
         ospath::{OsPath, OsPathOrFd},
-        stdlib::os::{_os, DirFd, SupportFunc, SymlinkArgs},
+        stdlib::os::{_os, AccessArgs, DirFd, SupportFunc, SymlinkArgs},
     };
     use core::hint::cold_path;
     use libc::intptr_t;
@@ -76,9 +76,21 @@ pub(crate) mod module {
     };
 
     #[pyfunction]
-    pub(super) fn access(path: OsPath, mode: u8, vm: &VirtualMachine) -> PyResult<bool> {
-        let _ = path.to_wide_cstring(vm)?;
-        Ok(host_nt::access(path.as_ref(), mode))
+    pub(super) fn access(args: AccessArgs<'_>, vm: &VirtualMachine) -> PyResult<bool> {
+        let [] = args.dir_fd.0;
+        if !args.follow_symlinks.0 {
+            return Err(vm.new_not_implemented_error(
+                "access: follow_symlinks unavailable on this platform",
+            ));
+        }
+        if args.effective_ids {
+            return Err(
+                vm.new_not_implemented_error("access: effective_ids unavailable on this platform")
+            );
+        }
+        let wide = args.path.to_wide_cstring(vm)?;
+
+        Ok(host_nt::access(&wide, args.mode))
     }
 
     #[pyfunction]

diff --git a/crates/vm/src/stdlib/os.rs b/crates/vm/src/stdlib/os.rs
@@ -144,6 +144,20 @@ pub(super) struct FollowSymlinks(
     #[pyarg(named, name = "follow_symlinks", default = true)] pub bool,
 );
 
+#[derive(FromArgs)]
+pub(super) struct AccessArgs<'fd> {
+    #[pyarg(any)]
+    pub(super) path: OsPath,
+    #[pyarg(any)]
+    pub(super) mode: u8,
+    #[pyarg(flatten)]
+    pub(super) dir_fd: DirFd<'fd, { _os::ACCESS_DIR_FD as usize }>,
+    #[pyarg(named, default)]
+    pub(super) effective_ids: bool,
+    #[pyarg(flatten)]
+    pub(super) follow_symlinks: FollowSymlinks,
+}
+
 #[cfg(not(windows))]
 fn bytes_as_os_str<'a>(b: &'a [u8], vm: &VirtualMachine) -> PyResult<&'a std::ffi::OsStr> {
     rustpython_host_env::os::bytes_as_os_str(b).map_err(|e| {
@@ -248,6 +262,15 @@ pub(super) mod _os {
     use rustpython_host_env::posix as host_posix;
     use std::{fs, io, path::PathBuf, time::SystemTime};
 
+    pub(crate) const ACCESS_DIR_FD: bool = cfg!(all(
+        unix,
+        not(any(
+            target_os = "android",
+            target_os = "espidf",
+            target_os = "horizon",
+            target_os = "vita",
+        ))
+    ));
     const OPEN_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
     pub(crate) const MKDIR_DIR_FD: bool = cfg!(any(unix, target_os = "wasi"));
     const STAT_DIR_FD: bool = cfg!(not(any(windows, target_os = "redox")));
@@ -2488,7 +2511,28 @@ pub(super) mod _os {
         let mut supports = super::platform::module::support_funcs();
         supports.extend(vec![
             SupportFunc::new("open", Some(false), Some(OPEN_DIR_FD), Some(false)),
-            SupportFunc::new("access", Some(false), Some(false), None),
+            SupportFunc::new(
+                "access",
+                Some(false),
+                Some(ACCESS_DIR_FD),
+                Some(cfg!(all(
+                    unix,
+                    not(any(
+                        target_os = "espidf",
+                        target_os = "horizon",
+                        target_os = "vita",
+                    )),
+                ))),
+            )
+            .with_effective_ids(Some(cfg!(all(
+                unix,
+                not(any(
+                    target_os = "android",
+                    target_os = "espidf",
+                    target_os = "horizon",
+                    target_os = "vita",
+                )),
+            )))),
             SupportFunc::new("chdir", None, Some(false), Some(false)),
             // chflags Some, None Some
             SupportFunc::new("link", Some(false), Some(false), Some(cfg!(unix))),
@@ -2530,6 +2574,7 @@ pub(crate) struct SupportFunc {
     fd: Option<bool>,
     dir_fd: Option<bool>,
     follow_symlinks: Option<bool>,
+    effective_ids: Option<bool>,
 }
 
 impl SupportFunc {
@@ -2544,15 +2589,22 @@ impl SupportFunc {
             fd,
             dir_fd,
             follow_symlinks,
+            effective_ids: None,
         }
     }
+
+    pub(crate) const fn with_effective_ids(mut self, effective_ids: Option<bool>) -> Self {
+        self.effective_ids = effective_ids;
+        self
+    }
 }
 
 pub fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {
     let support_funcs = _os::support_funcs();
     let supports_fd = PySet::default().into_ref(&vm.ctx);
     let supports_dir_fd = PySet::default().into_ref(&vm.ctx);
     let supports_follow_symlinks = PySet::default().into_ref(&vm.ctx);
+    let supports_effective_ids = PySet::default().into_ref(&vm.ctx);
     for support in support_funcs {
         let func_obj = module.get_attr(support.name, vm)?;
         if support.fd.unwrap_or(false) {
@@ -2562,14 +2614,18 @@ pub fn module_exec(vm: &VirtualMachine, module: &Py<PyModule>) -> PyResult<()> {
             supports_dir_fd.clone().add(func_obj.clone(), vm)?;
         }
         if support.follow_symlinks.unwrap_or(false) {
-            supports_follow_symlinks.clone().add(func_obj, vm)?;
+            supports_follow_symlinks.clone().add(func_obj.clone(), vm)?;
+        }
+        if support.effective_ids.unwrap_or(false) {
+            supports_effective_ids.clone().add(func_obj, vm)?;
         }
     }
 
     extend_module!(vm, module, {
         "supports_fd" => supports_fd,
         "supports_dir_fd" => supports_dir_fd,
         "supports_follow_symlinks" => supports_follow_symlinks,
+        "supports_effective_ids" => supports_effective_ids,
         "error" => vm.ctx.exceptions.os_error.to_owned(),
     });
 

diff --git a/crates/vm/src/stdlib/posix.rs b/crates/vm/src/stdlib/posix.rs
@@ -24,7 +24,8 @@ pub mod module {
         function::{ArgBytesLike, ArgMapping, Either, OptionalArg, PySsize},
         ospath::{OsPath, OsPathOrFd},
         stdlib::os::{
-            _os, DirFd, FollowSymlinks, SupportFunc, SymlinkArgs, fs_metadata, warn_if_bool_fd,
+            _os, AccessArgs, DirFd, FollowSymlinks, SupportFunc, SymlinkArgs, fs_metadata,
+            warn_if_bool_fd,
         },
     };
     #[cfg(any(
@@ -397,35 +398,55 @@ pub mod module {
             .collect())
     }
 
-    #[derive(FromArgs)]
-    pub(super) struct AccessArgs<'a> {
-        #[pyarg(any)]
-        path: OsPath,
-        #[pyarg(any)]
-        mode: u8,
-        #[pyarg(flatten)]
-        dir_fd: DirFd<'a, 0>,
-        #[pyarg(named, default)]
-        effective_ids: bool,
-        #[pyarg(flatten)]
-        follow_symlinks: FollowSymlinks,
-    }
-
     #[pyfunction]
     pub(super) fn access(args: AccessArgs<'_>, vm: &VirtualMachine) -> PyResult<bool> {
-        let [] = args.dir_fd.0;
+        #[cfg(any(
+            target_os = "android",
+            target_os = "espidf",
+            target_os = "horizon",
+            target_os = "vita",
+        ))]
         if args.effective_ids {
             return Err(
                 vm.new_not_implemented_error("access: effective_ids unavailable on this platform")
             );
         }
+        #[cfg(any(target_os = "espidf", target_os = "horizon", target_os = "vita",))]
         if !args.follow_symlinks.0 {
             return Err(vm.new_not_implemented_error(
                 "access: follow_symlinks unavailable on this platform",
             ));
         }
-        rustpython_host_env::posix::check_access(args.path.as_ref(), args.mode)
-            .map_err(|err| err.to_pyexception(vm))
+
+        #[cfg(all(
+            unix,
+            not(any(
+                target_os = "android",
+                target_os = "espidf",
+                target_os = "horizon",
+                target_os = "vita",
+            )),
+        ))]
+        let dir_fd = args.dir_fd.get_opt();
+        #[cfg(not(all(
+            unix,
+            not(any(
+                target_os = "android",
+                target_os = "espidf",
+                target_os = "horizon",
+                target_os = "vita",
+            )),
+        )))]
+        let dir_fd = None;
+
+        rustpython_host_env::posix::check_access(
+            dir_fd,
+            args.path.as_ref(),
+            args.mode,
+            args.effective_ids,
+            args.follow_symlinks.0,
+        )
+        .map_err(|err| err.to_pyexception(vm))
     }
 
     #[pyfunction]